mirror of
https://github.com/eliasstepanik/strudel-docker.git
synced 2026-01-11 21:58:31 +00:00
build
This commit is contained in:
Felix Roos
parent
8911326a95
commit
74e49aba79
@ -1,3 +0,0 @@
|
||||
export const MODE = "production";
|
||||
export const NODE_ENV = "production";
|
||||
export const SSR = false;
|
||||
@ -1,45 +0,0 @@
|
||||
import Fraction from "../pkg/fractionjs.js";
|
||||
import {TimeSpan} from "./strudel.js";
|
||||
Fraction.prototype.sam = function() {
|
||||
return this.floor();
|
||||
};
|
||||
Fraction.prototype.nextSam = function() {
|
||||
return this.sam().add(1);
|
||||
};
|
||||
Fraction.prototype.wholeCycle = function() {
|
||||
return new TimeSpan(this.sam(), this.nextSam());
|
||||
};
|
||||
Fraction.prototype.lt = function(other) {
|
||||
return this.compare(other) < 0;
|
||||
};
|
||||
Fraction.prototype.gt = function(other) {
|
||||
return this.compare(other) > 0;
|
||||
};
|
||||
Fraction.prototype.lte = function(other) {
|
||||
return this.compare(other) <= 0;
|
||||
};
|
||||
Fraction.prototype.gte = function(other) {
|
||||
return this.compare(other) >= 0;
|
||||
};
|
||||
Fraction.prototype.eq = function(other) {
|
||||
return this.compare(other) == 0;
|
||||
};
|
||||
Fraction.prototype.max = function(other) {
|
||||
return this.gt(other) ? this : other;
|
||||
};
|
||||
Fraction.prototype.min = function(other) {
|
||||
return this.lt(other) ? this : other;
|
||||
};
|
||||
Fraction.prototype.show = function() {
|
||||
return this.s * this.n + "/" + this.d;
|
||||
};
|
||||
Fraction.prototype.or = function(other) {
|
||||
return this.eq(0) ? other : this;
|
||||
};
|
||||
const fraction = (n) => {
|
||||
if (typeof n === "number") {
|
||||
n = String(n);
|
||||
}
|
||||
return Fraction(n);
|
||||
};
|
||||
export default fraction;
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,810 +0,0 @@
|
||||
import Fraction from "./fraction.js";
|
||||
import {compose} from "../pkg/ramda.js";
|
||||
import {isNote, toMidi} from "./util.js";
|
||||
const removeUndefineds = (xs) => xs.filter((x) => x != void 0);
|
||||
const flatten = (arr) => [].concat(...arr);
|
||||
const id = (a) => a;
|
||||
const range = (min, max) => Array.from({length: max - min + 1}, (_, i) => i + min);
|
||||
export function curry(func, overload) {
|
||||
const fn = function curried(...args) {
|
||||
if (args.length >= func.length) {
|
||||
return func.apply(this, args);
|
||||
} else {
|
||||
const partial = function(...args2) {
|
||||
return curried.apply(this, args.concat(args2));
|
||||
};
|
||||
if (overload) {
|
||||
overload(partial, args);
|
||||
}
|
||||
return partial;
|
||||
}
|
||||
};
|
||||
if (overload) {
|
||||
overload(fn, []);
|
||||
}
|
||||
return fn;
|
||||
}
|
||||
class TimeSpan {
|
||||
constructor(begin, end) {
|
||||
this.begin = Fraction(begin);
|
||||
this.end = Fraction(end);
|
||||
}
|
||||
get spanCycles() {
|
||||
const spans = [];
|
||||
var begin = this.begin;
|
||||
const end = this.end;
|
||||
const end_sam = end.sam();
|
||||
while (end.gt(begin)) {
|
||||
if (begin.sam().equals(end_sam)) {
|
||||
spans.push(new TimeSpan(begin, this.end));
|
||||
break;
|
||||
}
|
||||
const next_begin = begin.nextSam();
|
||||
spans.push(new TimeSpan(begin, next_begin));
|
||||
begin = next_begin;
|
||||
}
|
||||
return spans;
|
||||
}
|
||||
withTime(func_time) {
|
||||
return new TimeSpan(func_time(this.begin), func_time(this.end));
|
||||
}
|
||||
withEnd(func_time) {
|
||||
return new TimeSpan(this.begin, func_time(this.end));
|
||||
}
|
||||
intersection(other) {
|
||||
const intersect_begin = this.begin.max(other.begin);
|
||||
const intersect_end = this.end.min(other.end);
|
||||
if (intersect_begin.gt(intersect_end)) {
|
||||
return void 0;
|
||||
}
|
||||
if (intersect_begin.equals(intersect_end)) {
|
||||
if (intersect_begin.equals(this.end) && this.begin.lt(this.end)) {
|
||||
return void 0;
|
||||
}
|
||||
if (intersect_begin.equals(other.end) && other.begin.lt(other.end)) {
|
||||
return void 0;
|
||||
}
|
||||
}
|
||||
return new TimeSpan(intersect_begin, intersect_end);
|
||||
}
|
||||
intersection_e(other) {
|
||||
const result = this.intersection(other);
|
||||
if (result == void 0) {
|
||||
}
|
||||
return result;
|
||||
}
|
||||
midpoint() {
|
||||
return this.begin.add(this.end.sub(this.begin).div(Fraction(2)));
|
||||
}
|
||||
equals(other) {
|
||||
return this.begin.equals(other.begin) && this.end.equals(other.end);
|
||||
}
|
||||
show() {
|
||||
return this.begin.show() + " -> " + this.end.show();
|
||||
}
|
||||
}
|
||||
class Hap {
|
||||
constructor(whole, part, value, context = {}, stateful = false) {
|
||||
this.whole = whole;
|
||||
this.part = part;
|
||||
this.value = value;
|
||||
this.context = context;
|
||||
this.stateful = stateful;
|
||||
if (stateful) {
|
||||
console.assert(typeof this.value === "function", "Stateful values must be functions");
|
||||
}
|
||||
}
|
||||
withSpan(func) {
|
||||
const whole = this.whole ? func(this.whole) : void 0;
|
||||
return new Hap(whole, func(this.part), this.value, this.context);
|
||||
}
|
||||
withValue(func) {
|
||||
return new Hap(this.whole, this.part, func(this.value), this.context);
|
||||
}
|
||||
hasOnset() {
|
||||
return this.whole != void 0 && this.whole.begin.equals(this.part.begin);
|
||||
}
|
||||
resolveState(state) {
|
||||
if (this.stateful && this.hasOnset()) {
|
||||
console.log("stateful");
|
||||
const func = this.value;
|
||||
const [newState, newValue] = func(state);
|
||||
return [newState, new Hap(this.whole, this.part, newValue, this.context, false)];
|
||||
}
|
||||
return [state, this];
|
||||
}
|
||||
spanEquals(other) {
|
||||
return this.whole == void 0 && other.whole == void 0 || this.whole.equals(other.whole);
|
||||
}
|
||||
equals(other) {
|
||||
return this.spanEquals(other) && this.part.equals(other.part) && this.value === other.value;
|
||||
}
|
||||
show() {
|
||||
return "(" + (this.whole == void 0 ? "~" : this.whole.show()) + ", " + this.part.show() + ", " + this.value + ")";
|
||||
}
|
||||
setContext(context) {
|
||||
return new Hap(this.whole, this.part, this.value, context);
|
||||
}
|
||||
}
|
||||
export class State {
|
||||
constructor(span, controls = {}) {
|
||||
this.span = span;
|
||||
this.controls = controls;
|
||||
}
|
||||
setSpan(span) {
|
||||
return new State(span, this.controls);
|
||||
}
|
||||
withSpan(func) {
|
||||
return this.setSpan(func(this.span));
|
||||
}
|
||||
setControls(controls) {
|
||||
return new State(this.span, controls);
|
||||
}
|
||||
}
|
||||
class Pattern {
|
||||
constructor(query) {
|
||||
this.query = query;
|
||||
}
|
||||
_splitQueries() {
|
||||
const pat = this;
|
||||
const q = (state) => {
|
||||
return flatten(state.span.spanCycles.map((subspan) => pat.query(state.setSpan(subspan))));
|
||||
};
|
||||
return new Pattern(q);
|
||||
}
|
||||
withQuerySpan(func) {
|
||||
return new Pattern((state) => this.query(state.withSpan(func)));
|
||||
}
|
||||
withQueryTime(func) {
|
||||
return new Pattern((state) => this.query(state.withSpan((span) => span.withTime(func))));
|
||||
}
|
||||
withEventSpan(func) {
|
||||
return new Pattern((state) => this.query(state).map((hap) => hap.withSpan(func)));
|
||||
}
|
||||
withEventTime(func) {
|
||||
return this.withEventSpan((span) => span.withTime(func));
|
||||
}
|
||||
_withEvents(func) {
|
||||
return new Pattern((state) => func(this.query(state)));
|
||||
}
|
||||
_withEvent(func) {
|
||||
return this._withEvents((events) => events.map(func));
|
||||
}
|
||||
_setContext(context) {
|
||||
return this._withEvent((event) => event.setContext(context));
|
||||
}
|
||||
_withContext(func) {
|
||||
return this._withEvent((event) => event.setContext(func(event.context)));
|
||||
}
|
||||
_stripContext() {
|
||||
return this._withEvent((event) => event.setContext({}));
|
||||
}
|
||||
withLocation(start, end) {
|
||||
const location = {
|
||||
start: {line: start[0], column: start[1], offset: start[2]},
|
||||
end: {line: end[0], column: end[1], offset: end[2]}
|
||||
};
|
||||
return this._withContext((context) => {
|
||||
const locations = (context.locations || []).concat([location]);
|
||||
return {...context, locations};
|
||||
});
|
||||
}
|
||||
withMiniLocation(start, end) {
|
||||
const offset = {
|
||||
start: {line: start[0], column: start[1], offset: start[2]},
|
||||
end: {line: end[0], column: end[1], offset: end[2]}
|
||||
};
|
||||
return this._withContext((context) => {
|
||||
let locations = context.locations || [];
|
||||
locations = locations.map(({start: start2, end: end2}) => {
|
||||
const colOffset = start2.line === 1 ? offset.start.column : 0;
|
||||
return {
|
||||
start: {
|
||||
...start2,
|
||||
line: start2.line - 1 + (offset.start.line - 1) + 1,
|
||||
column: start2.column - 1 + colOffset
|
||||
},
|
||||
end: {
|
||||
...end2,
|
||||
line: end2.line - 1 + (offset.start.line - 1) + 1,
|
||||
column: end2.column - 1 + colOffset
|
||||
}
|
||||
};
|
||||
});
|
||||
return {...context, locations};
|
||||
});
|
||||
}
|
||||
withValue(func) {
|
||||
return new Pattern((state) => this.query(state).map((hap) => hap.withValue(func)));
|
||||
}
|
||||
fmap(func) {
|
||||
return this.withValue(func);
|
||||
}
|
||||
_filterEvents(event_test) {
|
||||
return new Pattern((state) => this.query(state).filter(event_test));
|
||||
}
|
||||
_filterValues(value_test) {
|
||||
return new Pattern((state) => this.query(state).filter((hap) => value_test(hap.value)));
|
||||
}
|
||||
_removeUndefineds() {
|
||||
return this._filterValues((val) => val != void 0);
|
||||
}
|
||||
onsetsOnly() {
|
||||
return this._filterEvents((hap) => hap.hasOnset());
|
||||
}
|
||||
_appWhole(whole_func, pat_val) {
|
||||
const pat_func = this;
|
||||
const query = function(state) {
|
||||
const event_funcs = pat_func.query(state);
|
||||
const event_vals = pat_val.query(state);
|
||||
const apply = function(event_func, event_val) {
|
||||
const s = event_func.part.intersection(event_val.part);
|
||||
if (s == void 0) {
|
||||
return void 0;
|
||||
}
|
||||
return new Hap(whole_func(event_func.whole, event_val.whole), s, event_func.value(event_val.value), event_val.context);
|
||||
};
|
||||
return flatten(event_funcs.map((event_func) => removeUndefineds(event_vals.map((event_val) => apply(event_func, event_val)))));
|
||||
};
|
||||
return new Pattern(query);
|
||||
}
|
||||
appBoth(pat_val) {
|
||||
const whole_func = function(span_a, span_b) {
|
||||
if (span_a == void 0 || span_b == void 0) {
|
||||
return void 0;
|
||||
}
|
||||
return span_a.intersection_e(span_b);
|
||||
};
|
||||
return this._appWhole(whole_func, pat_val);
|
||||
}
|
||||
appLeft(pat_val) {
|
||||
const pat_func = this;
|
||||
const query = function(state) {
|
||||
const haps = [];
|
||||
for (const hap_func of pat_func.query(state)) {
|
||||
const event_vals = pat_val.query(state.setSpan(hap_func.part));
|
||||
for (const hap_val of event_vals) {
|
||||
const new_whole = hap_func.whole;
|
||||
const new_part = hap_func.part.intersection_e(hap_val.part);
|
||||
const new_value = hap_func.value(hap_val.value);
|
||||
const hap = new Hap(new_whole, new_part, new_value, {
|
||||
...hap_val.context,
|
||||
...hap_func.context,
|
||||
locations: (hap_val.context.locations || []).concat(hap_func.context.locations || [])
|
||||
});
|
||||
haps.push(hap);
|
||||
}
|
||||
}
|
||||
return haps;
|
||||
};
|
||||
return new Pattern(query);
|
||||
}
|
||||
appRight(pat_val) {
|
||||
const pat_func = this;
|
||||
const query = function(state) {
|
||||
const haps = [];
|
||||
for (const hap_val of pat_val.query(state)) {
|
||||
const hap_funcs = pat_func.query(state.setSpan(hap_val.part));
|
||||
for (const hap_func of hap_funcs) {
|
||||
const new_whole = hap_val.whole;
|
||||
const new_part = hap_func.part.intersection_e(hap_val.part);
|
||||
const new_value = hap_func.value(hap_val.value);
|
||||
const hap = new Hap(new_whole, new_part, new_value, {
|
||||
...hap_func.context,
|
||||
...hap_val.context,
|
||||
locations: (hap_val.context.locations || []).concat(hap_func.context.locations || [])
|
||||
});
|
||||
haps.push(hap);
|
||||
}
|
||||
}
|
||||
return haps;
|
||||
};
|
||||
return new Pattern(query);
|
||||
}
|
||||
firstCycle(with_context = false) {
|
||||
var self = this;
|
||||
if (!with_context) {
|
||||
self = self._stripContext();
|
||||
}
|
||||
return self.query(new State(new TimeSpan(Fraction(0), Fraction(1))));
|
||||
}
|
||||
_sortEventsByPart() {
|
||||
return this._withEvents((events) => events.sort((a, b) => a.part.begin.sub(b.part.begin).or(a.part.end.sub(b.part.end)).or(a.whole.begin.sub(b.whole.begin).or(a.whole.end.sub(b.whole.end)))));
|
||||
}
|
||||
_opleft(other, func) {
|
||||
return this.fmap(func).appLeft(reify(other));
|
||||
}
|
||||
_asNumber(silent = false) {
|
||||
return this._withEvent((event) => {
|
||||
const asNumber = Number(event.value);
|
||||
if (!isNaN(asNumber)) {
|
||||
return event.withValue(() => asNumber);
|
||||
}
|
||||
const specialValue = {
|
||||
e: Math.E,
|
||||
pi: Math.PI
|
||||
}[event.value];
|
||||
if (typeof specialValue !== "undefined") {
|
||||
return event.withValue(() => specialValue);
|
||||
}
|
||||
if (isNote(event.value)) {
|
||||
return new Hap(event.whole, event.part, toMidi(event.value), {...event.context, type: "midi"});
|
||||
}
|
||||
if (!silent) {
|
||||
throw new Error('cannot parse as number: "' + event.value + '"');
|
||||
}
|
||||
return event.withValue(() => void 0);
|
||||
})._removeUndefineds();
|
||||
}
|
||||
add(other) {
|
||||
return this._asNumber()._opleft(other, (a) => (b) => a + b);
|
||||
}
|
||||
sub(other) {
|
||||
return this._asNumber()._opleft(other, (a) => (b) => a - b);
|
||||
}
|
||||
mul(other) {
|
||||
return this._asNumber()._opleft(other, (a) => (b) => a * b);
|
||||
}
|
||||
div(other) {
|
||||
return this._asNumber()._opleft(other, (a) => (b) => a / b);
|
||||
}
|
||||
round() {
|
||||
return this._asNumber().fmap((v) => Math.round(v));
|
||||
}
|
||||
floor() {
|
||||
return this._asNumber().fmap((v) => Math.floor(v));
|
||||
}
|
||||
ceil() {
|
||||
return this._asNumber().fmap((v) => Math.ceil(v));
|
||||
}
|
||||
union(other) {
|
||||
return this._opleft(other, (a) => (b) => Object.assign({}, a, b));
|
||||
}
|
||||
_bindWhole(choose_whole, func) {
|
||||
const pat_val = this;
|
||||
const query = function(state) {
|
||||
const withWhole = function(a, b) {
|
||||
return new Hap(choose_whole(a.whole, b.whole), b.part, b.value, Object.assign({}, a.context, b.context, {
|
||||
locations: (a.context.locations || []).concat(b.context.locations || [])
|
||||
}));
|
||||
};
|
||||
const match = function(a) {
|
||||
return func(a.value).query(state.setSpan(a.part)).map((b) => withWhole(a, b));
|
||||
};
|
||||
return flatten(pat_val.query(state).map((a) => match(a)));
|
||||
};
|
||||
return new Pattern(query);
|
||||
}
|
||||
bind(func) {
|
||||
const whole_func = function(a, b) {
|
||||
if (a == void 0 || b == void 0) {
|
||||
return void 0;
|
||||
}
|
||||
return a.intersection_e(b);
|
||||
};
|
||||
return this._bindWhole(whole_func, func);
|
||||
}
|
||||
join() {
|
||||
return this.bind(id);
|
||||
}
|
||||
innerBind(func) {
|
||||
return this._bindWhole((a, _) => a, func);
|
||||
}
|
||||
innerJoin() {
|
||||
return this.innerBind(id);
|
||||
}
|
||||
outerBind(func) {
|
||||
return this._bindWhole((_, b) => b, func);
|
||||
}
|
||||
outerJoin() {
|
||||
return this.outerBind(id);
|
||||
}
|
||||
_apply(func) {
|
||||
return func(this);
|
||||
}
|
||||
layer(...funcs) {
|
||||
return stack(...funcs.map((func) => func(this)));
|
||||
}
|
||||
_patternify(func) {
|
||||
const pat = this;
|
||||
const patterned = function(...args) {
|
||||
args = args.map((arg) => arg.constructor?.name === "Pattern" ? arg.fmap((value) => value.value || value) : arg);
|
||||
const pat_arg = sequence(...args);
|
||||
return pat_arg.fmap((arg) => func.call(pat, arg)).outerJoin();
|
||||
};
|
||||
return patterned;
|
||||
}
|
||||
_fastGap(factor) {
|
||||
const qf = function(span) {
|
||||
const cycle = span.begin.sam();
|
||||
const begin = cycle.add(span.begin.sub(cycle).mul(factor).min(1));
|
||||
const end = cycle.add(span.end.sub(cycle).mul(factor).min(1));
|
||||
return new TimeSpan(begin, end);
|
||||
};
|
||||
const ef = function(span) {
|
||||
const cycle = span.begin.sam();
|
||||
const begin = cycle.add(span.begin.sub(cycle).div(factor).min(1));
|
||||
const end = cycle.add(span.end.sub(cycle).div(factor).min(1));
|
||||
return new TimeSpan(begin, end);
|
||||
};
|
||||
return this.withQuerySpan(qf).withEventSpan(ef)._splitQueries();
|
||||
}
|
||||
_compressSpan(span) {
|
||||
const b = span.begin;
|
||||
const e = span.end;
|
||||
if (b > e || b > 1 || e > 1 || b < 0 || e < 0) {
|
||||
return silence;
|
||||
}
|
||||
return this._fastGap(Fraction(1).div(e.sub(b)))._late(b);
|
||||
}
|
||||
_fast(factor) {
|
||||
const fastQuery = this.withQueryTime((t) => t.mul(factor));
|
||||
return fastQuery.withEventTime((t) => t.div(factor));
|
||||
}
|
||||
_slow(factor) {
|
||||
return this._fast(Fraction(1).div(factor));
|
||||
}
|
||||
_cpm(cpm) {
|
||||
return this._fast(cpm / 60);
|
||||
}
|
||||
_early(offset) {
|
||||
offset = Fraction(offset);
|
||||
return this.withQueryTime((t) => t.add(offset)).withEventTime((t) => t.sub(offset));
|
||||
}
|
||||
_late(offset) {
|
||||
offset = Fraction(offset);
|
||||
return this._early(Fraction(0).sub(offset));
|
||||
}
|
||||
struct(...binary_pats) {
|
||||
const binary_pat = sequence(binary_pats);
|
||||
return binary_pat.fmap((b) => (val) => b ? val : void 0).appLeft(this)._removeUndefineds();
|
||||
}
|
||||
mask(...binary_pats) {
|
||||
const binary_pat = sequence(binary_pats);
|
||||
return binary_pat.fmap((b) => (val) => b ? val : void 0).appRight(this)._removeUndefineds();
|
||||
}
|
||||
_color(color) {
|
||||
return this._withContext((context) => ({...context, color}));
|
||||
}
|
||||
_segment(rate) {
|
||||
return this.struct(pure(true).fast(rate));
|
||||
}
|
||||
invert() {
|
||||
return this.fmap((x) => !x);
|
||||
}
|
||||
inv() {
|
||||
return this.invert();
|
||||
}
|
||||
when(binary_pat, func) {
|
||||
const true_pat = binary_pat._filterValues(id);
|
||||
const false_pat = binary_pat._filterValues((val) => !val);
|
||||
const with_pat = true_pat.fmap((_) => (y) => y).appRight(func(this));
|
||||
const without_pat = false_pat.fmap((_) => (y) => y).appRight(this);
|
||||
return stack(with_pat, without_pat);
|
||||
}
|
||||
off(time_pat, func) {
|
||||
return stack(this, func(this.late(time_pat)));
|
||||
}
|
||||
every(n, func) {
|
||||
const pat = this;
|
||||
const pats = Array(n - 1).fill(pat);
|
||||
pats.unshift(func(pat));
|
||||
return slowcatPrime(...pats);
|
||||
}
|
||||
append(other) {
|
||||
return fastcat(...[this, other]);
|
||||
}
|
||||
rev() {
|
||||
const pat = this;
|
||||
const query = function(state) {
|
||||
const span = state.span;
|
||||
const cycle = span.begin.sam();
|
||||
const next_cycle = span.begin.nextSam();
|
||||
const reflect = function(to_reflect) {
|
||||
const reflected = to_reflect.withTime((time) => cycle.add(next_cycle.sub(time)));
|
||||
const tmp = reflected.begin;
|
||||
reflected.begin = reflected.end;
|
||||
reflected.end = tmp;
|
||||
return reflected;
|
||||
};
|
||||
const haps = pat.query(state.setSpan(reflect(span)));
|
||||
return haps.map((hap) => hap.withSpan(reflect));
|
||||
};
|
||||
return new Pattern(query)._splitQueries();
|
||||
}
|
||||
jux(func, by = 1) {
|
||||
by /= 2;
|
||||
const elem_or = function(dict, key, dflt) {
|
||||
if (key in dict) {
|
||||
return dict[key];
|
||||
}
|
||||
return dflt;
|
||||
};
|
||||
const left = this.withValue((val) => Object.assign({}, val, {pan: elem_or(val, "pan", 0.5) - by}));
|
||||
const right = this.withValue((val) => Object.assign({}, val, {pan: elem_or(val, "pan", 0.5) + by}));
|
||||
return stack(left, func(right));
|
||||
}
|
||||
stack(...pats) {
|
||||
return stack(this, ...pats);
|
||||
}
|
||||
sequence(...pats) {
|
||||
return sequence(this, ...pats);
|
||||
}
|
||||
superimpose(...funcs) {
|
||||
return this.stack(...funcs.map((func) => func(this)));
|
||||
}
|
||||
stutWith(times, time, func) {
|
||||
return stack(...range(0, times - 1).map((i) => func(this.late(i * time), i)));
|
||||
}
|
||||
stut(times, feedback, time) {
|
||||
return this.stutWith(times, time, (pat, i) => pat.velocity(Math.pow(feedback, i)));
|
||||
}
|
||||
_echoWith(times, time, func) {
|
||||
return stack(...range(0, times - 1).map((i) => func(this.late(i * time), i)));
|
||||
}
|
||||
_echo(times, time, feedback) {
|
||||
return this._echoWith(times, time, (pat, i) => pat.velocity(Math.pow(feedback, i)));
|
||||
}
|
||||
iter(times) {
|
||||
return slowcat(...range(0, times - 1).map((i) => this.early(i / times)));
|
||||
}
|
||||
edit(...funcs) {
|
||||
return stack(...funcs.map((func) => func(this)));
|
||||
}
|
||||
pipe(func) {
|
||||
return func(this);
|
||||
}
|
||||
_bypass(on2) {
|
||||
on2 = Boolean(parseInt(on2));
|
||||
return on2 ? silence : this;
|
||||
}
|
||||
hush() {
|
||||
return silence;
|
||||
}
|
||||
_duration(value) {
|
||||
return this.withEventSpan((span) => new TimeSpan(span.begin, span.begin.add(value)));
|
||||
}
|
||||
_legato(value) {
|
||||
return this.withEventSpan((span) => new TimeSpan(span.begin, span.begin.add(span.end.sub(span.begin).mul(value))));
|
||||
}
|
||||
_velocity(velocity) {
|
||||
return this._withContext((context) => ({...context, velocity: (context.velocity || 1) * velocity}));
|
||||
}
|
||||
}
|
||||
Pattern.prototype.patternified = ["apply", "fast", "slow", "cpm", "early", "late", "duration", "legato", "velocity", "segment", "color"];
|
||||
Pattern.prototype.factories = {pure, stack, slowcat, fastcat, cat, timeCat, sequence, polymeter, pm, polyrhythm, pr};
|
||||
const silence = new Pattern((_) => []);
|
||||
function pure(value) {
|
||||
function query(state) {
|
||||
return state.span.spanCycles.map((subspan) => new Hap(Fraction(subspan.begin).wholeCycle(), subspan, value));
|
||||
}
|
||||
return new Pattern(query);
|
||||
}
|
||||
function steady(value) {
|
||||
return new Pattern((span) => Hap(void 0, span, value));
|
||||
}
|
||||
export const signal = (func) => {
|
||||
const query = (state) => [new Hap(void 0, state.span, func(state.span.midpoint()))];
|
||||
return new Pattern(query);
|
||||
};
|
||||
const _toBipolar = (pat) => pat.fmap((x) => x * 2 - 1);
|
||||
const _fromBipolar = (pat) => pat.fmap((x) => (x + 1) / 2);
|
||||
export const sine2 = signal((t) => Math.sin(Math.PI * 2 * t));
|
||||
export const sine = _fromBipolar(sine2);
|
||||
export const cosine2 = sine2._early(Fraction(1).div(4));
|
||||
export const cosine = sine._early(Fraction(1).div(4));
|
||||
export const saw = signal((t) => t % 1);
|
||||
export const saw2 = _toBipolar(saw);
|
||||
export const isaw = signal((t) => 1 - t % 1);
|
||||
export const isaw2 = _toBipolar(isaw);
|
||||
export const tri2 = fastcat(isaw2, saw2);
|
||||
export const tri = fastcat(isaw, saw);
|
||||
export const square = signal((t) => Math.floor(t * 2 % 2));
|
||||
export const square2 = _toBipolar(square);
|
||||
function reify(thing) {
|
||||
if (thing?.constructor?.name == "Pattern") {
|
||||
return thing;
|
||||
}
|
||||
return pure(thing);
|
||||
}
|
||||
function stack(...pats) {
|
||||
const reified = pats.map((pat) => reify(pat));
|
||||
const query = (state) => flatten(reified.map((pat) => pat.query(state)));
|
||||
return new Pattern(query);
|
||||
}
|
||||
function slowcat(...pats) {
|
||||
pats = pats.map(reify);
|
||||
const query = function(state) {
|
||||
const span = state.span;
|
||||
const pat_n = Math.floor(span.begin) % pats.length;
|
||||
const pat = pats[pat_n];
|
||||
if (!pat) {
|
||||
return [];
|
||||
}
|
||||
const offset = span.begin.floor().sub(span.begin.div(pats.length).floor());
|
||||
return pat.withEventTime((t) => t.add(offset)).query(state.setSpan(span.withTime((t) => t.sub(offset))));
|
||||
};
|
||||
return new Pattern(query)._splitQueries();
|
||||
}
|
||||
function slowcatPrime(...pats) {
|
||||
pats = pats.map(reify);
|
||||
const query = function(state) {
|
||||
const pat_n = Math.floor(state.span.begin) % pats.length;
|
||||
const pat = pats[pat_n];
|
||||
return pat.query(state);
|
||||
};
|
||||
return new Pattern(query)._splitQueries();
|
||||
}
|
||||
function fastcat(...pats) {
|
||||
return slowcat(...pats)._fast(pats.length);
|
||||
}
|
||||
function cat(...pats) {
|
||||
return fastcat(...pats);
|
||||
}
|
||||
function timeCat(...timepats) {
|
||||
const total = timepats.map((a) => a[0]).reduce((a, b) => a.add(b), Fraction(0));
|
||||
let begin = Fraction(0);
|
||||
const pats = [];
|
||||
for (const [time, pat] of timepats) {
|
||||
const end = begin.add(time);
|
||||
pats.push(reify(pat)._compressSpan(new TimeSpan(begin.div(total), end.div(total))));
|
||||
begin = end;
|
||||
}
|
||||
return stack(...pats);
|
||||
}
|
||||
function _sequenceCount(x) {
|
||||
if (Array.isArray(x)) {
|
||||
if (x.length == 0) {
|
||||
return [silence, 0];
|
||||
}
|
||||
if (x.length == 1) {
|
||||
return _sequenceCount(x[0]);
|
||||
}
|
||||
return [fastcat(...x.map((a) => _sequenceCount(a)[0])), x.length];
|
||||
}
|
||||
return [reify(x), 1];
|
||||
}
|
||||
function sequence(...xs) {
|
||||
return _sequenceCount(xs)[0];
|
||||
}
|
||||
function polymeter(steps = 0, ...args) {
|
||||
const seqs = args.map((a) => _sequenceCount(a));
|
||||
if (seqs.length == 0) {
|
||||
return silence;
|
||||
}
|
||||
if (steps == 0) {
|
||||
steps = seqs[0][1];
|
||||
}
|
||||
const pats = [];
|
||||
for (const seq of seqs) {
|
||||
if (seq[1] == 0) {
|
||||
next;
|
||||
}
|
||||
if (steps == seq[1]) {
|
||||
pats.push(seq[0]);
|
||||
} else {
|
||||
pats.push(seq[0]._fast(Fraction(steps).div(Fraction(seq[1]))));
|
||||
}
|
||||
}
|
||||
return stack(pats);
|
||||
}
|
||||
function pm(args) {
|
||||
polymeter(args);
|
||||
}
|
||||
function polyrhythm(...xs) {
|
||||
const seqs = xs.map((a) => sequence(a));
|
||||
if (seqs.length == 0) {
|
||||
return silence;
|
||||
}
|
||||
return stack(...seqs);
|
||||
}
|
||||
function pr(args) {
|
||||
polyrhythm(args);
|
||||
}
|
||||
const fast = curry((a, pat) => pat.fast(a));
|
||||
const slow = curry((a, pat) => pat.slow(a));
|
||||
const early = curry((a, pat) => pat.early(a));
|
||||
const late = curry((a, pat) => pat.late(a));
|
||||
const rev = (pat) => pat.rev();
|
||||
const add = curry((a, pat) => pat.add(a));
|
||||
const sub = curry((a, pat) => pat.sub(a));
|
||||
const mul = curry((a, pat) => pat.mul(a));
|
||||
const div = curry((a, pat) => pat.div(a));
|
||||
const union = curry((a, pat) => pat.union(a));
|
||||
const every = curry((i, f, pat) => pat.every(i, f));
|
||||
const when = curry((binary, f, pat) => pat.when(binary, f));
|
||||
const off = curry((t, f, pat) => pat.off(t, f));
|
||||
const jux = curry((f, pat) => pat.jux(f));
|
||||
const append = curry((a, pat) => pat.append(a));
|
||||
const superimpose = curry((array, pat) => pat.superimpose(...array));
|
||||
const struct = curry((a, pat) => pat.struct(a));
|
||||
const mask = curry((a, pat) => pat.mask(a));
|
||||
const invert = (pat) => pat.invert();
|
||||
const inv = (pat) => pat.inv();
|
||||
Pattern.prototype.composable = {fast, slow, early, late, superimpose};
|
||||
export function makeComposable(func) {
|
||||
Object.entries(Pattern.prototype.composable).forEach(([functionName, composable]) => {
|
||||
func[functionName] = (...args) => {
|
||||
const composition = compose(func, composable(...args));
|
||||
return makeComposable(composition);
|
||||
};
|
||||
});
|
||||
return func;
|
||||
}
|
||||
const patternify2 = (f) => (pata, patb, pat) => pata.fmap((a) => (b) => f.call(pat, a, b)).appLeft(patb).outerJoin();
|
||||
const patternify3 = (f) => (pata, patb, patc, pat) => pata.fmap((a) => (b) => (c) => f.call(pat, a, b, c)).appLeft(patb).appLeft(patc).outerJoin();
|
||||
const patternify4 = (f) => (pata, patb, patc, patd, pat) => pata.fmap((a) => (b) => (c) => (d) => f.call(pat, a, b, c, d)).appLeft(patb).appLeft(patc).appLeft(patd).outerJoin();
|
||||
Pattern.prototype.echo = function(...args) {
|
||||
args = args.map(reify);
|
||||
return patternify3(Pattern.prototype._echo)(...args, this);
|
||||
};
|
||||
Pattern.prototype.echoWith = function(...args) {
|
||||
args = args.map(reify);
|
||||
return patternify3(Pattern.prototype._echoWith)(...args, this);
|
||||
};
|
||||
Pattern.prototype.bootstrap = function() {
|
||||
const bootstrapped = Object.fromEntries(Object.entries(Pattern.prototype.composable).map(([functionName, composable]) => {
|
||||
if (Pattern.prototype[functionName]) {
|
||||
Pattern.prototype[functionName] = makeComposable(Pattern.prototype[functionName]);
|
||||
}
|
||||
return [functionName, curry(composable, makeComposable)];
|
||||
}));
|
||||
this.patternified.forEach((prop) => {
|
||||
Pattern.prototype[prop] = function(...args) {
|
||||
return this._patternify(Pattern.prototype["_" + prop])(...args);
|
||||
};
|
||||
});
|
||||
return bootstrapped;
|
||||
};
|
||||
Pattern.prototype.define = (name, func, options = {}) => {
|
||||
if (options.composable) {
|
||||
Pattern.prototype.composable[name] = func;
|
||||
}
|
||||
if (options.patternified) {
|
||||
Pattern.prototype.patternified = Pattern.prototype.patternified.concat([name]);
|
||||
}
|
||||
Pattern.prototype.bootstrap();
|
||||
};
|
||||
Pattern.prototype.define("hush", (pat) => pat.hush(), {patternified: false, composable: true});
|
||||
Pattern.prototype.define("bypass", (pat) => pat.bypass(on), {patternified: true, composable: true});
|
||||
export {
|
||||
Fraction,
|
||||
TimeSpan,
|
||||
Hap,
|
||||
Pattern,
|
||||
pure,
|
||||
stack,
|
||||
slowcat,
|
||||
fastcat,
|
||||
cat,
|
||||
timeCat,
|
||||
sequence,
|
||||
polymeter,
|
||||
pm,
|
||||
polyrhythm,
|
||||
pr,
|
||||
reify,
|
||||
silence,
|
||||
fast,
|
||||
slow,
|
||||
early,
|
||||
late,
|
||||
rev,
|
||||
add,
|
||||
sub,
|
||||
mul,
|
||||
div,
|
||||
union,
|
||||
every,
|
||||
when,
|
||||
off,
|
||||
jux,
|
||||
append,
|
||||
superimpose,
|
||||
struct,
|
||||
mask,
|
||||
invert,
|
||||
inv,
|
||||
id,
|
||||
range
|
||||
};
|
||||
@ -1,34 +0,0 @@
|
||||
export const isNote = (name) => /^[a-gA-G][#b]*[0-9]$/.test(name);
|
||||
export const tokenizeNote = (note) => {
|
||||
if (typeof note !== "string") {
|
||||
return [];
|
||||
}
|
||||
const [pc, acc = "", oct] = note.match(/^([a-gA-G])([#b]*)([0-9])?$/)?.slice(1) || [];
|
||||
if (!pc) {
|
||||
return [];
|
||||
}
|
||||
return [pc, acc, oct ? Number(oct) : void 0];
|
||||
};
|
||||
export const toMidi = (note) => {
|
||||
const [pc, acc, oct] = tokenizeNote(note);
|
||||
if (!pc) {
|
||||
throw new Error('not a note: "' + note + '"');
|
||||
}
|
||||
const chroma = {c: 0, d: 2, e: 4, f: 5, g: 7, a: 9, b: 11}[pc.toLowerCase()];
|
||||
const offset = acc?.split("").reduce((o, char) => o + {"#": 1, b: -1}[char], 0) || 0;
|
||||
return (Number(oct) + 1) * 12 + chroma + offset;
|
||||
};
|
||||
export const fromMidi = (n) => {
|
||||
return Math.pow(2, (n - 69) / 12) * 440;
|
||||
};
|
||||
export const mod = (n, m) => n < 0 ? mod(n + m, m) : n % m;
|
||||
export const getPlayableNoteValue = (event) => {
|
||||
let {value: note, context} = event;
|
||||
if (typeof note === "number" && context.type !== "frequency") {
|
||||
note = fromMidi(event.value);
|
||||
} else if (typeof note === "string" && !isNote(note)) {
|
||||
throw new Error("not a note: " + note);
|
||||
}
|
||||
return note;
|
||||
};
|
||||
export const rotate = (arr, n) => arr.slice(n).concat(arr.slice(0, n));
|
||||
@ -1 +0,0 @@
|
||||
export { b as Interval, a as Note, i as Scale } from '../common/index.es-d2606df1.js';
|
||||
@ -1,538 +0,0 @@
|
||||
import { T as ToneAudioNode, V as Volume, F as Frequency, M as Midi, S as Sampler, a as ToneAudioBuffers, b as ToneBufferSource, o as optionsFromArguments, G as Gain, i as isString } from '../common/index-b6fc655f.js';
|
||||
import '../common/webmidi.min-97732fd4.js';
|
||||
import '../common/_commonjsHelpers-8c19dec8.js';
|
||||
|
||||
var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||||
return new (P || (P = Promise))(function (resolve, reject) {
|
||||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||||
});
|
||||
};
|
||||
/**
|
||||
* Base class for the other components
|
||||
*/
|
||||
class PianoComponent extends ToneAudioNode {
|
||||
constructor(options) {
|
||||
super(options);
|
||||
this.name = 'PianoComponent';
|
||||
this.input = undefined;
|
||||
this.output = new Volume({ context: this.context });
|
||||
/**
|
||||
* If the component is enabled or not
|
||||
*/
|
||||
this._enabled = false;
|
||||
/**
|
||||
* The volume output of the component
|
||||
*/
|
||||
this.volume = this.output.volume;
|
||||
/**
|
||||
* Boolean indication of if the component is loaded or not
|
||||
*/
|
||||
this._loaded = false;
|
||||
this.volume.value = options.volume;
|
||||
this._enabled = options.enabled;
|
||||
this.samples = options.samples;
|
||||
}
|
||||
/**
|
||||
* If the samples are loaded or not
|
||||
*/
|
||||
get loaded() {
|
||||
return this._loaded;
|
||||
}
|
||||
/**
|
||||
* Load the samples
|
||||
*/
|
||||
load() {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
if (this._enabled) {
|
||||
yield this._internalLoad();
|
||||
this._loaded = true;
|
||||
}
|
||||
else {
|
||||
return Promise.resolve();
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// import * as Tone from '../node_modules/tone/Tone'
|
||||
function midiToNote(midi) {
|
||||
const frequency = Frequency(midi, 'midi');
|
||||
const ret = frequency.toNote();
|
||||
return ret;
|
||||
}
|
||||
function randomBetween(low, high) {
|
||||
return Math.random() * (high - low) + low;
|
||||
}
|
||||
|
||||
function getReleasesUrl(midi) {
|
||||
return `rel${midi - 20}.[mp3|ogg]`;
|
||||
}
|
||||
function getHarmonicsUrl(midi) {
|
||||
return `harmS${midiToNote(midi).replace('#', 's')}.[mp3|ogg]`;
|
||||
}
|
||||
function getNotesUrl(midi, vel) {
|
||||
return `${midiToNote(midi).replace('#', 's')}v${vel}.[mp3|ogg]`;
|
||||
}
|
||||
/**
|
||||
* Maps velocity depths to Salamander velocities
|
||||
*/
|
||||
const velocitiesMap = {
|
||||
1: [8],
|
||||
2: [6, 12],
|
||||
3: [1, 7, 15],
|
||||
4: [1, 5, 10, 15],
|
||||
5: [1, 4, 8, 12, 16],
|
||||
6: [1, 3, 7, 10, 13, 16],
|
||||
7: [1, 3, 6, 9, 11, 13, 16],
|
||||
8: [1, 3, 5, 7, 9, 11, 13, 16],
|
||||
9: [1, 3, 5, 7, 9, 11, 13, 15, 16],
|
||||
10: [1, 2, 3, 5, 7, 9, 11, 13, 15, 16],
|
||||
11: [1, 2, 3, 5, 7, 9, 11, 13, 14, 15, 16],
|
||||
12: [1, 2, 3, 4, 5, 7, 9, 11, 13, 14, 15, 16],
|
||||
13: [1, 2, 3, 4, 5, 7, 9, 11, 12, 13, 14, 15, 16],
|
||||
14: [1, 2, 3, 4, 5, 6, 7, 9, 11, 12, 13, 14, 15, 16],
|
||||
15: [1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 16],
|
||||
16: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
|
||||
};
|
||||
/**
|
||||
* All the notes of audio samples
|
||||
*/
|
||||
const allNotes = [
|
||||
21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54,
|
||||
57, 60, 63, 66, 69, 72, 75, 78, 81, 84,
|
||||
87, 90, 93, 96, 99, 102, 105, 108
|
||||
];
|
||||
function getNotesInRange(min, max) {
|
||||
return allNotes.filter(note => min <= note && note <= max);
|
||||
}
|
||||
/**
|
||||
* All the notes of audio samples
|
||||
*/
|
||||
const harmonics = [21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87];
|
||||
function getHarmonicsInRange(min, max) {
|
||||
return harmonics.filter(note => min <= note && note <= max);
|
||||
}
|
||||
function inHarmonicsRange(note) {
|
||||
return harmonics[0] <= note && note <= harmonics[harmonics.length - 1];
|
||||
}
|
||||
|
||||
class Harmonics extends PianoComponent {
|
||||
constructor(options) {
|
||||
super(options);
|
||||
this._urls = {};
|
||||
const notes = getHarmonicsInRange(options.minNote, options.maxNote);
|
||||
for (const n of notes) {
|
||||
this._urls[n] = getHarmonicsUrl(n);
|
||||
}
|
||||
}
|
||||
triggerAttack(note, time, velocity) {
|
||||
if (this._enabled && inHarmonicsRange(note)) {
|
||||
this._sampler.triggerAttack(Midi(note).toNote(), time, velocity * randomBetween(0.5, 1));
|
||||
}
|
||||
}
|
||||
_internalLoad() {
|
||||
return new Promise(onload => {
|
||||
this._sampler = new Sampler({
|
||||
baseUrl: this.samples,
|
||||
onload,
|
||||
urls: this._urls,
|
||||
}).connect(this.output);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
class Keybed extends PianoComponent {
|
||||
constructor(options) {
|
||||
super(options);
|
||||
/**
|
||||
* The urls to load
|
||||
*/
|
||||
this._urls = {};
|
||||
for (let i = options.minNote; i <= options.maxNote; i++) {
|
||||
this._urls[i] = getReleasesUrl(i);
|
||||
}
|
||||
}
|
||||
_internalLoad() {
|
||||
return new Promise(success => {
|
||||
this._buffers = new ToneAudioBuffers(this._urls, success, this.samples);
|
||||
});
|
||||
}
|
||||
start(note, time, velocity) {
|
||||
if (this._enabled && this._buffers.has(note)) {
|
||||
const source = new ToneBufferSource({
|
||||
url: this._buffers.get(note),
|
||||
context: this.context,
|
||||
}).connect(this.output);
|
||||
// randomize the velocity slightly
|
||||
source.start(time, 0, undefined, 0.015 * velocity * randomBetween(0.5, 1));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Pedal extends PianoComponent {
|
||||
constructor(options) {
|
||||
super(options);
|
||||
this._downTime = Infinity;
|
||||
this._currentSound = null;
|
||||
this._downTime = Infinity;
|
||||
}
|
||||
_internalLoad() {
|
||||
return new Promise((success) => {
|
||||
this._buffers = new ToneAudioBuffers({
|
||||
down1: 'pedalD1.mp3',
|
||||
down2: 'pedalD2.mp3',
|
||||
up1: 'pedalU1.mp3',
|
||||
up2: 'pedalU2.mp3',
|
||||
}, success, this.samples);
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Squash the current playing sound
|
||||
*/
|
||||
_squash(time) {
|
||||
if (this._currentSound && this._currentSound.state !== 'stopped') {
|
||||
this._currentSound.stop(time);
|
||||
}
|
||||
this._currentSound = null;
|
||||
}
|
||||
_playSample(time, dir) {
|
||||
if (this._enabled) {
|
||||
this._currentSound = new ToneBufferSource({
|
||||
url: this._buffers.get(`${dir}${Math.random() > 0.5 ? 1 : 2}`),
|
||||
context: this.context,
|
||||
curve: 'exponential',
|
||||
fadeIn: 0.05,
|
||||
fadeOut: 0.1,
|
||||
}).connect(this.output);
|
||||
this._currentSound.start(time, randomBetween(0, 0.01), undefined, 0.1 * randomBetween(0.5, 1));
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Put the pedal down
|
||||
*/
|
||||
down(time) {
|
||||
this._squash(time);
|
||||
this._downTime = time;
|
||||
this._playSample(time, 'down');
|
||||
}
|
||||
/**
|
||||
* Put the pedal up
|
||||
*/
|
||||
up(time) {
|
||||
this._squash(time);
|
||||
this._downTime = Infinity;
|
||||
this._playSample(time, 'up');
|
||||
}
|
||||
/**
|
||||
* Indicates if the pedal is down at the given time
|
||||
*/
|
||||
isDown(time) {
|
||||
return time > this._downTime;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A single velocity of strings
|
||||
*/
|
||||
class PianoString extends ToneAudioNode {
|
||||
constructor(options) {
|
||||
super(options);
|
||||
this.name = 'PianoString';
|
||||
this._urls = {};
|
||||
// create the urls
|
||||
options.notes.forEach(note => this._urls[note] = getNotesUrl(note, options.velocity));
|
||||
this.samples = options.samples;
|
||||
}
|
||||
load() {
|
||||
return new Promise(onload => {
|
||||
this._sampler = this.output = new Sampler({
|
||||
attack: 0,
|
||||
baseUrl: this.samples,
|
||||
curve: 'exponential',
|
||||
onload,
|
||||
release: 0.4,
|
||||
urls: this._urls,
|
||||
volume: 3,
|
||||
});
|
||||
});
|
||||
}
|
||||
triggerAttack(note, time, velocity) {
|
||||
this._sampler.triggerAttack(note, time, velocity);
|
||||
}
|
||||
triggerRelease(note, time) {
|
||||
this._sampler.triggerRelease(note, time);
|
||||
}
|
||||
}
|
||||
|
||||
var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||||
return new (P || (P = Promise))(function (resolve, reject) {
|
||||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||||
});
|
||||
};
|
||||
/**
|
||||
* Manages all of the hammered string sounds
|
||||
*/
|
||||
class PianoStrings extends PianoComponent {
|
||||
constructor(options) {
|
||||
super(options);
|
||||
const notes = getNotesInRange(options.minNote, options.maxNote);
|
||||
const velocities = velocitiesMap[options.velocities].slice();
|
||||
this._strings = velocities.map(velocity => {
|
||||
const string = new PianoString(Object.assign(options, {
|
||||
notes, velocity,
|
||||
}));
|
||||
return string;
|
||||
});
|
||||
this._activeNotes = new Map();
|
||||
}
|
||||
/**
|
||||
* Scale a value between a given range
|
||||
*/
|
||||
scale(val, inMin, inMax, outMin, outMax) {
|
||||
return ((val - inMin) / (inMax - inMin)) * (outMax - outMin) + outMin;
|
||||
}
|
||||
triggerAttack(note, time, velocity) {
|
||||
const scaledVel = this.scale(velocity, 0, 1, -0.5, this._strings.length - 0.51);
|
||||
const stringIndex = Math.max(Math.round(scaledVel), 0);
|
||||
let gain = 1 + scaledVel - stringIndex;
|
||||
if (this._strings.length === 1) {
|
||||
gain = velocity;
|
||||
}
|
||||
const sampler = this._strings[stringIndex];
|
||||
if (this._activeNotes.has(note)) {
|
||||
this.triggerRelease(note, time);
|
||||
}
|
||||
this._activeNotes.set(note, sampler);
|
||||
sampler.triggerAttack(Midi(note).toNote(), time, gain);
|
||||
}
|
||||
triggerRelease(note, time) {
|
||||
// trigger the release of all of the notes at that velociy
|
||||
if (this._activeNotes.has(note)) {
|
||||
this._activeNotes.get(note).triggerRelease(Midi(note).toNote(), time);
|
||||
this._activeNotes.delete(note);
|
||||
}
|
||||
}
|
||||
_internalLoad() {
|
||||
return __awaiter$1(this, void 0, void 0, function* () {
|
||||
yield Promise.all(this._strings.map((s) => __awaiter$1(this, void 0, void 0, function* () {
|
||||
yield s.load();
|
||||
s.connect(this.output);
|
||||
})));
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
var __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||||
return new (P || (P = Promise))(function (resolve, reject) {
|
||||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||||
});
|
||||
};
|
||||
/**
|
||||
* The Piano
|
||||
*/
|
||||
class Piano extends ToneAudioNode {
|
||||
constructor() {
|
||||
super(optionsFromArguments(Piano.getDefaults(), arguments));
|
||||
this.name = 'Piano';
|
||||
this.input = undefined;
|
||||
this.output = new Gain({ context: this.context });
|
||||
/**
|
||||
* The currently held notes
|
||||
*/
|
||||
this._heldNotes = new Map();
|
||||
/**
|
||||
* If it's loaded or not
|
||||
*/
|
||||
this._loaded = false;
|
||||
const options = optionsFromArguments(Piano.getDefaults(), arguments);
|
||||
// make sure it ends with a /
|
||||
if (!options.url.endsWith('/')) {
|
||||
options.url += '/';
|
||||
}
|
||||
this.maxPolyphony = options.maxPolyphony;
|
||||
this._heldNotes = new Map();
|
||||
this._sustainedNotes = new Map();
|
||||
this._strings = new PianoStrings(Object.assign({}, options, {
|
||||
enabled: true,
|
||||
samples: options.url,
|
||||
volume: options.volume.strings,
|
||||
})).connect(this.output);
|
||||
this.strings = this._strings.volume;
|
||||
this._pedal = new Pedal(Object.assign({}, options, {
|
||||
enabled: options.pedal,
|
||||
samples: options.url,
|
||||
volume: options.volume.pedal,
|
||||
})).connect(this.output);
|
||||
this.pedal = this._pedal.volume;
|
||||
this._keybed = new Keybed(Object.assign({}, options, {
|
||||
enabled: options.release,
|
||||
samples: options.url,
|
||||
volume: options.volume.keybed,
|
||||
})).connect(this.output);
|
||||
this.keybed = this._keybed.volume;
|
||||
this._harmonics = new Harmonics(Object.assign({}, options, {
|
||||
enabled: options.release,
|
||||
samples: options.url,
|
||||
volume: options.volume.harmonics,
|
||||
})).connect(this.output);
|
||||
this.harmonics = this._harmonics.volume;
|
||||
}
|
||||
static getDefaults() {
|
||||
return Object.assign(ToneAudioNode.getDefaults(), {
|
||||
maxNote: 108,
|
||||
minNote: 21,
|
||||
pedal: true,
|
||||
release: false,
|
||||
url: 'https://tambien.github.io/Piano/audio/',
|
||||
velocities: 1,
|
||||
maxPolyphony: 32,
|
||||
volume: {
|
||||
harmonics: 0,
|
||||
keybed: 0,
|
||||
pedal: 0,
|
||||
strings: 0,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Load all the samples
|
||||
*/
|
||||
load() {
|
||||
return __awaiter$2(this, void 0, void 0, function* () {
|
||||
yield Promise.all([
|
||||
this._strings.load(),
|
||||
this._pedal.load(),
|
||||
this._keybed.load(),
|
||||
this._harmonics.load(),
|
||||
]);
|
||||
this._loaded = true;
|
||||
});
|
||||
}
|
||||
/**
|
||||
* If all the samples are loaded or not
|
||||
*/
|
||||
get loaded() {
|
||||
return this._loaded;
|
||||
}
|
||||
/**
|
||||
* Put the pedal down at the given time. Causes subsequent
|
||||
* notes and currently held notes to sustain.
|
||||
*/
|
||||
pedalDown({ time = this.immediate() } = {}) {
|
||||
if (this.loaded) {
|
||||
time = this.toSeconds(time);
|
||||
if (!this._pedal.isDown(time)) {
|
||||
this._pedal.down(time);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
/**
|
||||
* Put the pedal up. Dampens sustained notes
|
||||
*/
|
||||
pedalUp({ time = this.immediate() } = {}) {
|
||||
if (this.loaded) {
|
||||
const seconds = this.toSeconds(time);
|
||||
if (this._pedal.isDown(seconds)) {
|
||||
this._pedal.up(seconds);
|
||||
// dampen each of the notes
|
||||
this._sustainedNotes.forEach((t, note) => {
|
||||
if (!this._heldNotes.has(note)) {
|
||||
this._strings.triggerRelease(note, seconds);
|
||||
}
|
||||
});
|
||||
this._sustainedNotes.clear();
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
/**
|
||||
* Play a note.
|
||||
* @param note The note to play. If it is a number, it is assumed to be MIDI
|
||||
* @param velocity The velocity to play the note
|
||||
* @param time The time of the event
|
||||
*/
|
||||
keyDown({ note, midi, time = this.immediate(), velocity = 0.8 }) {
|
||||
if (this.loaded && this.maxPolyphony > this._heldNotes.size + this._sustainedNotes.size) {
|
||||
time = this.toSeconds(time);
|
||||
if (isString(note)) {
|
||||
midi = Math.round(Midi(note).toMidi());
|
||||
}
|
||||
if (!this._heldNotes.has(midi)) {
|
||||
// record the start time and velocity
|
||||
this._heldNotes.set(midi, { time, velocity });
|
||||
this._strings.triggerAttack(midi, time, velocity);
|
||||
}
|
||||
}
|
||||
else {
|
||||
console.warn('samples not loaded');
|
||||
}
|
||||
return this;
|
||||
}
|
||||
/**
|
||||
* Release a held note.
|
||||
*/
|
||||
keyUp({ note, midi, time = this.immediate(), velocity = 0.8 }) {
|
||||
if (this.loaded) {
|
||||
time = this.toSeconds(time);
|
||||
if (isString(note)) {
|
||||
midi = Math.round(Midi(note).toMidi());
|
||||
}
|
||||
if (this._heldNotes.has(midi)) {
|
||||
const prevNote = this._heldNotes.get(midi);
|
||||
this._heldNotes.delete(midi);
|
||||
// compute the release velocity
|
||||
const holdTime = Math.pow(Math.max(time - prevNote.time, 0.1), 0.7);
|
||||
const prevVel = prevNote.velocity;
|
||||
let dampenGain = (3 / holdTime) * prevVel * velocity;
|
||||
dampenGain = Math.max(dampenGain, 0.4);
|
||||
dampenGain = Math.min(dampenGain, 4);
|
||||
if (this._pedal.isDown(time)) {
|
||||
if (!this._sustainedNotes.has(midi)) {
|
||||
this._sustainedNotes.set(midi, time);
|
||||
}
|
||||
}
|
||||
else {
|
||||
// release the string sound
|
||||
this._strings.triggerRelease(midi, time);
|
||||
// trigger the harmonics sound
|
||||
this._harmonics.triggerAttack(midi, time, dampenGain);
|
||||
}
|
||||
// trigger the keybed release sound
|
||||
this._keybed.start(midi, time, velocity);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
stopAll() {
|
||||
this.pedalUp();
|
||||
this._heldNotes.forEach((_, midi) => {
|
||||
this.keyUp({ midi });
|
||||
});
|
||||
return this;
|
||||
}
|
||||
}
|
||||
|
||||
var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||||
return new (P || (P = Promise))(function (resolve, reject) {
|
||||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||||
});
|
||||
};
|
||||
|
||||
export { Piano };
|
||||
@ -1,41 +0,0 @@
|
||||
function bjorklund(slots, pulses){
|
||||
var pattern = [],
|
||||
count = [],
|
||||
remainder = [pulses],
|
||||
divisor = slots - pulses,
|
||||
level = 0,
|
||||
build_pattern = function(lv){
|
||||
if( lv == -1 ){ pattern.push(0); }
|
||||
else if( lv == -2 ){ pattern.push(1); }
|
||||
else {
|
||||
for(var x=0; x<count[lv]; x++){
|
||||
build_pattern(lv-1);
|
||||
}
|
||||
|
||||
if(remainder[lv]){
|
||||
build_pattern(lv-2);
|
||||
}
|
||||
}
|
||||
}
|
||||
;
|
||||
|
||||
while(remainder[level] > 1){
|
||||
count.push(Math.floor(divisor/remainder[level]));
|
||||
remainder.push(divisor%remainder[level]);
|
||||
divisor = remainder[level];
|
||||
level++;
|
||||
}
|
||||
count.push(divisor);
|
||||
|
||||
build_pattern(level);
|
||||
|
||||
return pattern.reverse();
|
||||
}
|
||||
|
||||
|
||||
var bjork = function(m, k){
|
||||
if(m > k) return bjorklund(m, k);
|
||||
else return bjorklund(k, m);
|
||||
};
|
||||
|
||||
export default bjork;
|
||||
@ -1,828 +0,0 @@
|
||||
import { c as createCommonjsModule, a as commonjsGlobal, g as getDefaultExportFromCjs } from './common/_commonjsHelpers-8c19dec8.js';
|
||||
import { n as note, t as transpose$2, d as distance$1, m as modes, c as all, e as tokenizeNote, g as get$2, f as deprecate, h as isSupersetOf, j as all$1, k as isSubsetOf, l as get$3, o as interval, p as compact$1, q as toMidi, r as range$1, s as midiToNoteName, C as Core, u as index$5, v as index$1$1, w as index$1$2, x as index$6, y as index$7, b as index$8, z as index$9, A as index$a, B as index$1$3, a as index$b, D as index$c, i as index$d, E as accToAlt, F as altToAcc, G as coordToInterval, H as coordToNote, I as decode, J as encode, K as fillStr$1, L as isNamed, M as isPitch, N as stepToLetter, O as tokenizeInterval } from './common/index.es-d2606df1.js';
|
||||
|
||||
const fillStr = (character, times) => Array(times + 1).join(character);
|
||||
const REGEX = /^(_{1,}|=|\^{1,}|)([abcdefgABCDEFG])([,']*)$/;
|
||||
function tokenize(str) {
|
||||
const m = REGEX.exec(str);
|
||||
if (!m) {
|
||||
return ["", "", ""];
|
||||
}
|
||||
return [m[1], m[2], m[3]];
|
||||
}
|
||||
/**
|
||||
* Convert a (string) note in ABC notation into a (string) note in scientific notation
|
||||
*
|
||||
* @example
|
||||
* abcToScientificNotation("c") // => "C5"
|
||||
*/
|
||||
function abcToScientificNotation(str) {
|
||||
const [acc, letter, oct] = tokenize(str);
|
||||
if (letter === "") {
|
||||
return "";
|
||||
}
|
||||
let o = 4;
|
||||
for (let i = 0; i < oct.length; i++) {
|
||||
o += oct.charAt(i) === "," ? -1 : 1;
|
||||
}
|
||||
const a = acc[0] === "_"
|
||||
? acc.replace(/_/g, "b")
|
||||
: acc[0] === "^"
|
||||
? acc.replace(/\^/g, "#")
|
||||
: "";
|
||||
return letter.charCodeAt(0) > 96
|
||||
? letter.toUpperCase() + a + (o + 1)
|
||||
: letter + a + o;
|
||||
}
|
||||
/**
|
||||
* Convert a (string) note in scientific notation into a (string) note in ABC notation
|
||||
*
|
||||
* @example
|
||||
* scientificToAbcNotation("C#4") // => "^C"
|
||||
*/
|
||||
function scientificToAbcNotation(str) {
|
||||
const n = note(str);
|
||||
if (n.empty || (!n.oct && n.oct !== 0)) {
|
||||
return "";
|
||||
}
|
||||
const { letter, acc, oct } = n;
|
||||
const a = acc[0] === "b" ? acc.replace(/b/g, "_") : acc.replace(/#/g, "^");
|
||||
const l = oct > 4 ? letter.toLowerCase() : letter;
|
||||
const o = oct === 5 ? "" : oct > 4 ? fillStr("'", oct - 5) : fillStr(",", 4 - oct);
|
||||
return a + l + o;
|
||||
}
|
||||
function transpose(note, interval) {
|
||||
return scientificToAbcNotation(transpose$2(abcToScientificNotation(note), interval));
|
||||
}
|
||||
function distance(from, to) {
|
||||
return distance$1(abcToScientificNotation(from), abcToScientificNotation(to));
|
||||
}
|
||||
var index = {
|
||||
abcToScientificNotation,
|
||||
scientificToAbcNotation,
|
||||
tokenize,
|
||||
transpose,
|
||||
distance,
|
||||
};
|
||||
|
||||
// ascending range
|
||||
function ascR(b, n) {
|
||||
const a = [];
|
||||
// tslint:disable-next-line:curly
|
||||
for (; n--; a[n] = n + b)
|
||||
;
|
||||
return a;
|
||||
}
|
||||
// descending range
|
||||
function descR(b, n) {
|
||||
const a = [];
|
||||
// tslint:disable-next-line:curly
|
||||
for (; n--; a[n] = b - n)
|
||||
;
|
||||
return a;
|
||||
}
|
||||
/**
|
||||
* Creates a numeric range
|
||||
*
|
||||
* @param {number} from
|
||||
* @param {number} to
|
||||
* @return {Array<number>}
|
||||
*
|
||||
* @example
|
||||
* range(-2, 2) // => [-2, -1, 0, 1, 2]
|
||||
* range(2, -2) // => [2, 1, 0, -1, -2]
|
||||
*/
|
||||
function range(from, to) {
|
||||
return from < to ? ascR(from, to - from + 1) : descR(from, from - to + 1);
|
||||
}
|
||||
/**
|
||||
* Rotates a list a number of times. It"s completly agnostic about the
|
||||
* contents of the list.
|
||||
*
|
||||
* @param {Integer} times - the number of rotations
|
||||
* @param {Array} array
|
||||
* @return {Array} the rotated array
|
||||
*
|
||||
* @example
|
||||
* rotate(1, [1, 2, 3]) // => [2, 3, 1]
|
||||
*/
|
||||
function rotate(times, arr) {
|
||||
const len = arr.length;
|
||||
const n = ((times % len) + len) % len;
|
||||
return arr.slice(n, len).concat(arr.slice(0, n));
|
||||
}
|
||||
/**
|
||||
* Return a copy of the array with the null values removed
|
||||
* @function
|
||||
* @param {Array} array
|
||||
* @return {Array}
|
||||
*
|
||||
* @example
|
||||
* compact(["a", "b", null, "c"]) // => ["a", "b", "c"]
|
||||
*/
|
||||
function compact(arr) {
|
||||
return arr.filter((n) => n === 0 || n);
|
||||
}
|
||||
/**
|
||||
* Sort an array of notes in ascending order. Pitch classes are listed
|
||||
* before notes. Any string that is not a note is removed.
|
||||
*
|
||||
* @param {string[]} notes
|
||||
* @return {string[]} sorted array of notes
|
||||
*
|
||||
* @example
|
||||
* sortedNoteNames(['c2', 'c5', 'c1', 'c0', 'c6', 'c'])
|
||||
* // => ['C', 'C0', 'C1', 'C2', 'C5', 'C6']
|
||||
* sortedNoteNames(['c', 'F', 'G', 'a', 'b', 'h', 'J'])
|
||||
* // => ['C', 'F', 'G', 'A', 'B']
|
||||
*/
|
||||
function sortedNoteNames(notes) {
|
||||
const valid = notes.map((n) => note(n)).filter((n) => !n.empty);
|
||||
return valid.sort((a, b) => a.height - b.height).map((n) => n.name);
|
||||
}
|
||||
/**
|
||||
* Get sorted notes with duplicates removed. Pitch classes are listed
|
||||
* before notes.
|
||||
*
|
||||
* @function
|
||||
* @param {string[]} array
|
||||
* @return {string[]} unique sorted notes
|
||||
*
|
||||
* @example
|
||||
* Array.sortedUniqNoteNames(['a', 'b', 'c2', '1p', 'p2', 'c2', 'b', 'c', 'c3' ])
|
||||
* // => [ 'C', 'A', 'B', 'C2', 'C3' ]
|
||||
*/
|
||||
function sortedUniqNoteNames(arr) {
|
||||
return sortedNoteNames(arr).filter((n, i, a) => i === 0 || n !== a[i - 1]);
|
||||
}
|
||||
/**
|
||||
* Randomizes the order of the specified array in-place, using the Fisher–Yates shuffle.
|
||||
*
|
||||
* @function
|
||||
* @param {Array} array
|
||||
* @return {Array} the array shuffled
|
||||
*
|
||||
* @example
|
||||
* shuffle(["C", "D", "E", "F"]) // => [...]
|
||||
*/
|
||||
function shuffle(arr, rnd = Math.random) {
|
||||
let i;
|
||||
let t;
|
||||
let m = arr.length;
|
||||
while (m) {
|
||||
i = Math.floor(rnd() * m--);
|
||||
t = arr[m];
|
||||
arr[m] = arr[i];
|
||||
arr[i] = t;
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
/**
|
||||
* Get all permutations of an array
|
||||
*
|
||||
* @param {Array} array - the array
|
||||
* @return {Array<Array>} an array with all the permutations
|
||||
* @example
|
||||
* permutations(["a", "b", "c"])) // =>
|
||||
* [
|
||||
* ["a", "b", "c"],
|
||||
* ["b", "a", "c"],
|
||||
* ["b", "c", "a"],
|
||||
* ["a", "c", "b"],
|
||||
* ["c", "a", "b"],
|
||||
* ["c", "b", "a"]
|
||||
* ]
|
||||
*/
|
||||
function permutations(arr) {
|
||||
if (arr.length === 0) {
|
||||
return [[]];
|
||||
}
|
||||
return permutations(arr.slice(1)).reduce((acc, perm) => {
|
||||
return acc.concat(arr.map((e, pos) => {
|
||||
const newPerm = perm.slice();
|
||||
newPerm.splice(pos, 0, arr[0]);
|
||||
return newPerm;
|
||||
}));
|
||||
}, []);
|
||||
}
|
||||
|
||||
var index_es = /*#__PURE__*/Object.freeze({
|
||||
__proto__: null,
|
||||
compact: compact,
|
||||
permutations: permutations,
|
||||
range: range,
|
||||
rotate: rotate,
|
||||
shuffle: shuffle,
|
||||
sortedNoteNames: sortedNoteNames,
|
||||
sortedUniqNoteNames: sortedUniqNoteNames
|
||||
});
|
||||
|
||||
const namedSet = (notes) => {
|
||||
const pcToName = notes.reduce((record, n) => {
|
||||
const chroma = note(n).chroma;
|
||||
if (chroma !== undefined) {
|
||||
record[chroma] = record[chroma] || note(n).name;
|
||||
}
|
||||
return record;
|
||||
}, {});
|
||||
return (chroma) => pcToName[chroma];
|
||||
};
|
||||
function detect(source) {
|
||||
const notes = source.map((n) => note(n).pc).filter((x) => x);
|
||||
if (note.length === 0) {
|
||||
return [];
|
||||
}
|
||||
const found = findExactMatches(notes, 1);
|
||||
return found
|
||||
.filter((chord) => chord.weight)
|
||||
.sort((a, b) => b.weight - a.weight)
|
||||
.map((chord) => chord.name);
|
||||
}
|
||||
function findExactMatches(notes, weight) {
|
||||
const tonic = notes[0];
|
||||
const tonicChroma = note(tonic).chroma;
|
||||
const noteName = namedSet(notes);
|
||||
// we need to test all chormas to get the correct baseNote
|
||||
const allModes = modes(notes, false);
|
||||
const found = [];
|
||||
allModes.forEach((mode, index) => {
|
||||
// some chords could have the same chroma but different interval spelling
|
||||
const chordTypes = all().filter((chordType) => chordType.chroma === mode);
|
||||
chordTypes.forEach((chordType) => {
|
||||
const chordName = chordType.aliases[0];
|
||||
const baseNote = noteName(index);
|
||||
const isInversion = index !== tonicChroma;
|
||||
if (isInversion) {
|
||||
found.push({
|
||||
weight: 0.5 * weight,
|
||||
name: `${baseNote}${chordName}/${tonic}`,
|
||||
});
|
||||
}
|
||||
else {
|
||||
found.push({ weight: 1 * weight, name: `${baseNote}${chordName}` });
|
||||
}
|
||||
});
|
||||
});
|
||||
return found;
|
||||
}
|
||||
|
||||
const NoChord = {
|
||||
empty: true,
|
||||
name: "",
|
||||
symbol: "",
|
||||
root: "",
|
||||
rootDegree: 0,
|
||||
type: "",
|
||||
tonic: null,
|
||||
setNum: NaN,
|
||||
quality: "Unknown",
|
||||
chroma: "",
|
||||
normalized: "",
|
||||
aliases: [],
|
||||
notes: [],
|
||||
intervals: [],
|
||||
};
|
||||
// 6, 64, 7, 9, 11 and 13 are consider part of the chord
|
||||
// (see https://github.com/danigb/tonal/issues/55)
|
||||
const NUM_TYPES = /^(6|64|7|9|11|13)$/;
|
||||
/**
|
||||
* Tokenize a chord name. It returns an array with the tonic and chord type
|
||||
* If not tonic is found, all the name is considered the chord name.
|
||||
*
|
||||
* This function does NOT check if the chord type exists or not. It only tries
|
||||
* to split the tonic and chord type.
|
||||
*
|
||||
* @function
|
||||
* @param {string} name - the chord name
|
||||
* @return {Array} an array with [tonic, type]
|
||||
* @example
|
||||
* tokenize("Cmaj7") // => [ "C", "maj7" ]
|
||||
* tokenize("C7") // => [ "C", "7" ]
|
||||
* tokenize("mMaj7") // => [ null, "mMaj7" ]
|
||||
* tokenize("Cnonsense") // => [ null, "nonsense" ]
|
||||
*/
|
||||
function tokenize$1(name) {
|
||||
const [letter, acc, oct, type] = tokenizeNote(name);
|
||||
if (letter === "") {
|
||||
return ["", name];
|
||||
}
|
||||
// aug is augmented (see https://github.com/danigb/tonal/issues/55)
|
||||
if (letter === "A" && type === "ug") {
|
||||
return ["", "aug"];
|
||||
}
|
||||
// see: https://github.com/tonaljs/tonal/issues/70
|
||||
if (!type && (oct === "4" || oct === "5")) {
|
||||
return [letter + acc, oct];
|
||||
}
|
||||
if (NUM_TYPES.test(oct)) {
|
||||
return [letter + acc, oct + type];
|
||||
}
|
||||
else {
|
||||
return [letter + acc + oct, type];
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Get a Chord from a chord name.
|
||||
*/
|
||||
function get(src) {
|
||||
if (src === "") {
|
||||
return NoChord;
|
||||
}
|
||||
if (Array.isArray(src) && src.length === 2) {
|
||||
return getChord(src[1], src[0]);
|
||||
}
|
||||
else {
|
||||
const [tonic, type] = tokenize$1(src);
|
||||
const chord = getChord(type, tonic);
|
||||
return chord.empty ? getChord(src) : chord;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Get chord properties
|
||||
*
|
||||
* @param typeName - the chord type name
|
||||
* @param [tonic] - Optional tonic
|
||||
* @param [root] - Optional root (requires a tonic)
|
||||
*/
|
||||
function getChord(typeName, optionalTonic, optionalRoot) {
|
||||
const type = get$2(typeName);
|
||||
const tonic = note(optionalTonic || "");
|
||||
const root = note(optionalRoot || "");
|
||||
if (type.empty ||
|
||||
(optionalTonic && tonic.empty) ||
|
||||
(optionalRoot && root.empty)) {
|
||||
return NoChord;
|
||||
}
|
||||
const rootInterval = distance$1(tonic.pc, root.pc);
|
||||
const rootDegree = type.intervals.indexOf(rootInterval) + 1;
|
||||
if (!root.empty && !rootDegree) {
|
||||
return NoChord;
|
||||
}
|
||||
const intervals = Array.from(type.intervals);
|
||||
for (let i = 1; i < rootDegree; i++) {
|
||||
const num = intervals[0][0];
|
||||
const quality = intervals[0][1];
|
||||
const newNum = parseInt(num, 10) + 7;
|
||||
intervals.push(`${newNum}${quality}`);
|
||||
intervals.shift();
|
||||
}
|
||||
const notes = tonic.empty
|
||||
? []
|
||||
: intervals.map((i) => transpose$2(tonic, i));
|
||||
typeName = type.aliases.indexOf(typeName) !== -1 ? typeName : type.aliases[0];
|
||||
const symbol = `${tonic.empty ? "" : tonic.pc}${typeName}${root.empty || rootDegree <= 1 ? "" : "/" + root.pc}`;
|
||||
const name = `${optionalTonic ? tonic.pc + " " : ""}${type.name}${rootDegree > 1 && optionalRoot ? " over " + root.pc : ""}`;
|
||||
return {
|
||||
...type,
|
||||
name,
|
||||
symbol,
|
||||
type: type.name,
|
||||
root: root.name,
|
||||
intervals,
|
||||
rootDegree,
|
||||
tonic: tonic.name,
|
||||
notes,
|
||||
};
|
||||
}
|
||||
const chord = deprecate("Chord.chord", "Chord.get", get);
|
||||
/**
|
||||
* Transpose a chord name
|
||||
*
|
||||
* @param {string} chordName - the chord name
|
||||
* @return {string} the transposed chord
|
||||
*
|
||||
* @example
|
||||
* transpose('Dm7', 'P4') // => 'Gm7
|
||||
*/
|
||||
function transpose$1(chordName, interval) {
|
||||
const [tonic, type] = tokenize$1(chordName);
|
||||
if (!tonic) {
|
||||
return chordName;
|
||||
}
|
||||
return transpose$2(tonic, interval) + type;
|
||||
}
|
||||
/**
|
||||
* Get all scales where the given chord fits
|
||||
*
|
||||
* @example
|
||||
* chordScales('C7b9')
|
||||
* // => ["phrygian dominant", "flamenco", "spanish heptatonic", "half-whole diminished", "chromatic"]
|
||||
*/
|
||||
function chordScales(name) {
|
||||
const s = get(name);
|
||||
const isChordIncluded = isSupersetOf(s.chroma);
|
||||
return all$1()
|
||||
.filter((scale) => isChordIncluded(scale.chroma))
|
||||
.map((scale) => scale.name);
|
||||
}
|
||||
/**
|
||||
* Get all chords names that are a superset of the given one
|
||||
* (has the same notes and at least one more)
|
||||
*
|
||||
* @function
|
||||
* @example
|
||||
* extended("CMaj7")
|
||||
* // => [ 'Cmaj#4', 'Cmaj7#9#11', 'Cmaj9', 'CM7add13', 'Cmaj13', 'Cmaj9#11', 'CM13#11', 'CM7b9' ]
|
||||
*/
|
||||
function extended(chordName) {
|
||||
const s = get(chordName);
|
||||
const isSuperset = isSupersetOf(s.chroma);
|
||||
return all()
|
||||
.filter((chord) => isSuperset(chord.chroma))
|
||||
.map((chord) => s.tonic + chord.aliases[0]);
|
||||
}
|
||||
/**
|
||||
* Find all chords names that are a subset of the given one
|
||||
* (has less notes but all from the given chord)
|
||||
*
|
||||
* @example
|
||||
*/
|
||||
function reduced(chordName) {
|
||||
const s = get(chordName);
|
||||
const isSubset = isSubsetOf(s.chroma);
|
||||
return all()
|
||||
.filter((chord) => isSubset(chord.chroma))
|
||||
.map((chord) => s.tonic + chord.aliases[0]);
|
||||
}
|
||||
var index$1 = {
|
||||
getChord,
|
||||
get,
|
||||
detect,
|
||||
chordScales,
|
||||
extended,
|
||||
reduced,
|
||||
tokenize: tokenize$1,
|
||||
transpose: transpose$1,
|
||||
// deprecate
|
||||
chord,
|
||||
};
|
||||
|
||||
/**
|
||||
* Given a tonic and a chord list expressed with roman numeral notation
|
||||
* returns the progression expressed with leadsheet chords symbols notation
|
||||
* @example
|
||||
* fromRomanNumerals("C", ["I", "IIm7", "V7"]);
|
||||
* // => ["C", "Dm7", "G7"]
|
||||
*/
|
||||
function fromRomanNumerals(tonic, chords) {
|
||||
const romanNumerals = chords.map(get$3);
|
||||
return romanNumerals.map((rn) => transpose$2(tonic, interval(rn)) + rn.chordType);
|
||||
}
|
||||
/**
|
||||
* Given a tonic and a chord list with leadsheet symbols notation,
|
||||
* return the chord list with roman numeral notation
|
||||
* @example
|
||||
* toRomanNumerals("C", ["CMaj7", "Dm7", "G7"]);
|
||||
* // => ["IMaj7", "IIm7", "V7"]
|
||||
*/
|
||||
function toRomanNumerals(tonic, chords) {
|
||||
return chords.map((chord) => {
|
||||
const [note, chordType] = tokenize$1(chord);
|
||||
const intervalName = distance$1(tonic, note);
|
||||
const roman = get$3(interval(intervalName));
|
||||
return roman.name + chordType;
|
||||
});
|
||||
}
|
||||
var index$2 = { fromRomanNumerals, toRomanNumerals };
|
||||
|
||||
/**
|
||||
* Create a numeric range. You supply a list of notes or numbers and it will
|
||||
* be connected to create complex ranges.
|
||||
*
|
||||
* @param {Array} notes - the list of notes or midi numbers used
|
||||
* @return {Array} an array of numbers or empty array if not valid parameters
|
||||
*
|
||||
* @example
|
||||
* numeric(["C5", "C4"]) // => [ 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60 ]
|
||||
* // it works midi notes
|
||||
* numeric([10, 5]) // => [ 10, 9, 8, 7, 6, 5 ]
|
||||
* // complex range
|
||||
* numeric(["C4", "E4", "Bb3"]) // => [60, 61, 62, 63, 64, 63, 62, 61, 60, 59, 58]
|
||||
*/
|
||||
function numeric(notes) {
|
||||
const midi = compact$1(notes.map(toMidi));
|
||||
if (!notes.length || midi.length !== notes.length) {
|
||||
// there is no valid notes
|
||||
return [];
|
||||
}
|
||||
return midi.reduce((result, note) => {
|
||||
const last = result[result.length - 1];
|
||||
return result.concat(range$1(last, note).slice(1));
|
||||
}, [midi[0]]);
|
||||
}
|
||||
/**
|
||||
* Create a range of chromatic notes. The altered notes will use flats.
|
||||
*
|
||||
* @function
|
||||
* @param {Array} notes - the list of notes or midi note numbers to create a range from
|
||||
* @param {Object} options - The same as `midiToNoteName` (`{ sharps: boolean, pitchClass: boolean }`)
|
||||
* @return {Array} an array of note names
|
||||
*
|
||||
* @example
|
||||
* Range.chromatic(["C2, "E2", "D2"]) // => ["C2", "Db2", "D2", "Eb2", "E2", "Eb2", "D2"]
|
||||
* // with sharps
|
||||
* Range.chromatic(["C2", "C3"], { sharps: true }) // => [ "C2", "C#2", "D2", "D#2", "E2", "F2", "F#2", "G2", "G#2", "A2", "A#2", "B2", "C3" ]
|
||||
*/
|
||||
function chromatic(notes, options) {
|
||||
return numeric(notes).map((midi) => midiToNoteName(midi, options));
|
||||
}
|
||||
var index$3 = { numeric, chromatic };
|
||||
|
||||
// CONSTANTS
|
||||
const NONE = {
|
||||
empty: true,
|
||||
name: "",
|
||||
upper: undefined,
|
||||
lower: undefined,
|
||||
type: undefined,
|
||||
additive: [],
|
||||
};
|
||||
const NAMES = ["4/4", "3/4", "2/4", "2/2", "12/8", "9/8", "6/8", "3/8"];
|
||||
// PUBLIC API
|
||||
function names() {
|
||||
return NAMES.slice();
|
||||
}
|
||||
const REGEX$1 = /^(\d?\d(?:\+\d)*)\/(\d)$/;
|
||||
const CACHE = new Map();
|
||||
function get$1(literal) {
|
||||
const cached = CACHE.get(literal);
|
||||
if (cached) {
|
||||
return cached;
|
||||
}
|
||||
const ts = build(parse(literal));
|
||||
CACHE.set(literal, ts);
|
||||
return ts;
|
||||
}
|
||||
function parse(literal) {
|
||||
if (typeof literal === "string") {
|
||||
const [_, up, low] = REGEX$1.exec(literal) || [];
|
||||
return parse([up, low]);
|
||||
}
|
||||
const [up, down] = literal;
|
||||
const denominator = +down;
|
||||
if (typeof up === "number") {
|
||||
return [up, denominator];
|
||||
}
|
||||
const list = up.split("+").map((n) => +n);
|
||||
return list.length === 1 ? [list[0], denominator] : [list, denominator];
|
||||
}
|
||||
var index$4 = { names, parse, get: get$1 };
|
||||
// PRIVATE
|
||||
function build([up, down]) {
|
||||
const upper = Array.isArray(up) ? up.reduce((a, b) => a + b, 0) : up;
|
||||
const lower = down;
|
||||
if (upper === 0 || lower === 0) {
|
||||
return NONE;
|
||||
}
|
||||
const name = Array.isArray(up) ? `${up.join("+")}/${down}` : `${up}/${down}`;
|
||||
const additive = Array.isArray(up) ? up : [];
|
||||
const type = lower === 4 || lower === 2
|
||||
? "simple"
|
||||
: lower === 8 && upper % 3 === 0
|
||||
? "compound"
|
||||
: "irregular";
|
||||
return {
|
||||
empty: false,
|
||||
name,
|
||||
type,
|
||||
upper,
|
||||
lower,
|
||||
additive,
|
||||
};
|
||||
}
|
||||
|
||||
// deprecated (backwards compatibility)
|
||||
const Tonal = Core;
|
||||
const PcSet = index$5;
|
||||
const ChordDictionary = index$1$1;
|
||||
const ScaleDictionary = index$1$2;
|
||||
|
||||
var index_es$1 = /*#__PURE__*/Object.freeze({
|
||||
__proto__: null,
|
||||
Array: index_es,
|
||||
Core: Core,
|
||||
ChordDictionary: ChordDictionary,
|
||||
PcSet: PcSet,
|
||||
ScaleDictionary: ScaleDictionary,
|
||||
Tonal: Tonal,
|
||||
AbcNotation: index,
|
||||
Chord: index$1,
|
||||
ChordType: index$1$1,
|
||||
Collection: index$6,
|
||||
DurationValue: index$7,
|
||||
Interval: index$8,
|
||||
Key: index$9,
|
||||
Midi: index$a,
|
||||
Mode: index$1$3,
|
||||
Note: index$b,
|
||||
Pcset: index$5,
|
||||
Progression: index$2,
|
||||
Range: index$3,
|
||||
RomanNumeral: index$c,
|
||||
Scale: index$d,
|
||||
ScaleType: index$1$2,
|
||||
TimeSignature: index$4,
|
||||
accToAlt: accToAlt,
|
||||
altToAcc: altToAcc,
|
||||
coordToInterval: coordToInterval,
|
||||
coordToNote: coordToNote,
|
||||
decode: decode,
|
||||
deprecate: deprecate,
|
||||
distance: distance$1,
|
||||
encode: encode,
|
||||
fillStr: fillStr$1,
|
||||
interval: interval,
|
||||
isNamed: isNamed,
|
||||
isPitch: isPitch,
|
||||
note: note,
|
||||
stepToLetter: stepToLetter,
|
||||
tokenizeInterval: tokenizeInterval,
|
||||
tokenizeNote: tokenizeNote,
|
||||
transpose: transpose$2
|
||||
});
|
||||
|
||||
var getBestVoicing_1 = createCommonjsModule(function (module, exports) {
|
||||
exports.__esModule = true;
|
||||
exports.getBestVoicing = void 0;
|
||||
function getBestVoicing(voicingOptions) {
|
||||
var chord = voicingOptions.chord, range = voicingOptions.range, finder = voicingOptions.finder, picker = voicingOptions.picker, lastVoicing = voicingOptions.lastVoicing;
|
||||
var voicings = finder(chord, range);
|
||||
if (!voicings.length) {
|
||||
return [];
|
||||
}
|
||||
return picker(voicings, lastVoicing);
|
||||
}
|
||||
exports.getBestVoicing = getBestVoicing;
|
||||
|
||||
});
|
||||
|
||||
var tokenizeChord_1 = createCommonjsModule(function (module, exports) {
|
||||
exports.__esModule = true;
|
||||
exports.tokenizeChord = void 0;
|
||||
function tokenizeChord(chord) {
|
||||
var match = (chord || '').match(/^([A-G][b#]*)([^\/]*)[\/]?([A-G][b#]*)?$/);
|
||||
if (!match) {
|
||||
// console.warn('could not tokenize chord', chord);
|
||||
return [];
|
||||
}
|
||||
return match.slice(1);
|
||||
}
|
||||
exports.tokenizeChord = tokenizeChord;
|
||||
|
||||
});
|
||||
|
||||
var voicingsInRange_1 = createCommonjsModule(function (module, exports) {
|
||||
exports.__esModule = true;
|
||||
exports.voicingsInRange = void 0;
|
||||
|
||||
|
||||
|
||||
function voicingsInRange(chord, dictionary, range) {
|
||||
if (dictionary === void 0) { dictionary = dictionaryVoicing_1.lefthand; }
|
||||
if (range === void 0) { range = ['D3', 'A4']; }
|
||||
var _a = (0, tokenizeChord_1.tokenizeChord)(chord), tonic = _a[0], symbol = _a[1];
|
||||
if (!dictionary[symbol]) {
|
||||
return [];
|
||||
}
|
||||
// resolve array of interval arrays for the wanted symbol
|
||||
var voicings = dictionary[symbol].map(function (intervals) { return intervals.split(' '); });
|
||||
var notesInRange = index_es$1.Range.chromatic(range); // gives array of notes inside range
|
||||
return voicings.reduce(function (voiced, voicing) {
|
||||
// transpose intervals relative to first interval (e.g. 3m 5P > 1P 3M)
|
||||
var relativeIntervals = voicing.map(function (interval) { return index_es$1.Interval.substract(interval, voicing[0]); });
|
||||
// get enharmonic correct pitch class the bottom note
|
||||
var bottomPitchClass = index_es$1.Note.transpose(tonic, voicing[0]);
|
||||
// get all possible start notes for voicing
|
||||
var starts = notesInRange
|
||||
// only get the start notes:
|
||||
.filter(function (note) { return index_es$1.Note.chroma(note) === index_es$1.Note.chroma(bottomPitchClass); })
|
||||
// filter out start notes that will overshoot the top end of the range
|
||||
.filter(function (note) {
|
||||
return index_es$1.Note.midi(index_es$1.Note.transpose(note, relativeIntervals[relativeIntervals.length - 1])) <= index_es$1.Note.midi(range[1]);
|
||||
})
|
||||
// replace Range.chromatic notes with the correct enharmonic equivalents
|
||||
.map(function (note) { return index_es$1.Note.enharmonic(note, bottomPitchClass); });
|
||||
// render one voicing for each start note
|
||||
var notes = starts.map(function (start) { return relativeIntervals.map(function (interval) { return index_es$1.Note.transpose(start, interval); }); });
|
||||
return voiced.concat(notes);
|
||||
}, []);
|
||||
}
|
||||
exports.voicingsInRange = voicingsInRange;
|
||||
|
||||
});
|
||||
|
||||
var dictionaryVoicing_1 = createCommonjsModule(function (module, exports) {
|
||||
var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
|
||||
__assign = Object.assign || function(t) {
|
||||
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
||||
s = arguments[i];
|
||||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
||||
t[p] = s[p];
|
||||
}
|
||||
return t;
|
||||
};
|
||||
return __assign.apply(this, arguments);
|
||||
};
|
||||
var __rest = (commonjsGlobal && commonjsGlobal.__rest) || function (s, e) {
|
||||
var t = {};
|
||||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
|
||||
t[p] = s[p];
|
||||
if (s != null && typeof Object.getOwnPropertySymbols === "function")
|
||||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
||||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
|
||||
t[p[i]] = s[p[i]];
|
||||
}
|
||||
return t;
|
||||
};
|
||||
exports.__esModule = true;
|
||||
exports.dictionaryVoicing = exports.dictionaryVoicingFinder = exports.triads = exports.guidetones = exports.lefthand = void 0;
|
||||
|
||||
|
||||
exports.lefthand = {
|
||||
m7: ['3m 5P 7m 9M', '7m 9M 10m 12P'],
|
||||
'7': ['3M 6M 7m 9M', '7m 9M 10M 13M'],
|
||||
'^7': ['3M 5P 7M 9M', '7M 9M 10M 12P'],
|
||||
'69': ['3M 5P 6A 9M'],
|
||||
m7b5: ['3m 5d 7m 8P', '7m 8P 10m 12d'],
|
||||
'7b9': ['3M 6m 7m 9m', '7m 9m 10M 13m'],
|
||||
'7b13': ['3M 6m 7m 9m', '7m 9m 10M 13m'],
|
||||
o7: ['1P 3m 5d 6M', '5d 6M 8P 10m'],
|
||||
'7#11': ['7m 9M 11A 13A'],
|
||||
'7#9': ['3M 7m 9A'],
|
||||
mM7: ['3m 5P 7M 9M', '7M 9M 10m 12P'],
|
||||
m6: ['3m 5P 6M 9M', '6M 9M 10m 12P']
|
||||
};
|
||||
exports.guidetones = {
|
||||
m7: ['3m 7m', '7m 10m'],
|
||||
m9: ['3m 7m', '7m 10m'],
|
||||
'7': ['3M 7m', '7m 10M'],
|
||||
'^7': ['3M 7M', '7M 10M'],
|
||||
'^9': ['3M 7M', '7M 10M'],
|
||||
'69': ['3M 6M'],
|
||||
'6': ['3M 6M', '6M 10M'],
|
||||
m7b5: ['3m 7m', '7m 10m'],
|
||||
'7b9': ['3M 7m', '7m 10M'],
|
||||
'7b13': ['3M 7m', '7m 10M'],
|
||||
o7: ['3m 6M', '6M 10m'],
|
||||
'7#11': ['3M 7m', '7m 10M'],
|
||||
'7#9': ['3M 7m', '7m 10M'],
|
||||
mM7: ['3m 7M', '7M 10m'],
|
||||
m6: ['3m 6M', '6M 10m']
|
||||
};
|
||||
exports.triads = {
|
||||
M: ['1P 3M 5P', '3M 5P 8P', '5P 8P 10M'],
|
||||
m: ['1P 3m 5P', '3m 5P 8P', '5P 8P 10m'],
|
||||
o: ['1P 3m 5d', '3m 5d 8P', '5d 8P 10m'],
|
||||
aug: ['1P 3m 5A', '3m 5A 8P', '5A 8P 10m']
|
||||
};
|
||||
var dictionaryVoicingFinder = function (dictionary) { return function (chordSymbol, range) {
|
||||
return (0, voicingsInRange_1.voicingsInRange)(chordSymbol, dictionary, range);
|
||||
}; };
|
||||
exports.dictionaryVoicingFinder = dictionaryVoicingFinder;
|
||||
var dictionaryVoicing = function (props) {
|
||||
var dictionary = props.dictionary, range = props.range, rest = __rest(props, ["dictionary", "range"]);
|
||||
return (0, getBestVoicing_1.getBestVoicing)(__assign(__assign({}, rest), { range: range, finder: (0, exports.dictionaryVoicingFinder)(dictionary) }));
|
||||
};
|
||||
exports.dictionaryVoicing = dictionaryVoicing;
|
||||
|
||||
});
|
||||
|
||||
var minTopNoteDiff_1 = createCommonjsModule(function (module, exports) {
|
||||
exports.__esModule = true;
|
||||
exports.minTopNoteDiff = void 0;
|
||||
|
||||
function minTopNoteDiff(voicings, lastVoicing) {
|
||||
if (!lastVoicing) {
|
||||
return voicings[0];
|
||||
}
|
||||
var diff = function (voicing) {
|
||||
return Math.abs(index_es$1.Note.midi(lastVoicing[lastVoicing.length - 1]) - index_es$1.Note.midi(voicing[voicing.length - 1]));
|
||||
};
|
||||
return voicings.reduce(function (best, current) { return (diff(current) < diff(best) ? current : best); }, voicings[0]);
|
||||
}
|
||||
exports.minTopNoteDiff = minTopNoteDiff;
|
||||
|
||||
});
|
||||
|
||||
var dist = createCommonjsModule(function (module, exports) {
|
||||
exports.__esModule = true;
|
||||
|
||||
|
||||
|
||||
|
||||
exports["default"] = {
|
||||
tokenizeChord: tokenizeChord_1.tokenizeChord,
|
||||
getBestVoicing: getBestVoicing_1.getBestVoicing,
|
||||
dictionaryVoicing: dictionaryVoicing_1.dictionaryVoicing,
|
||||
dictionaryVoicingFinder: dictionaryVoicing_1.dictionaryVoicingFinder,
|
||||
lefthand: dictionaryVoicing_1.lefthand,
|
||||
guidetones: dictionaryVoicing_1.guidetones,
|
||||
triads: dictionaryVoicing_1.triads,
|
||||
minTopNoteDiff: minTopNoteDiff_1.minTopNoteDiff
|
||||
};
|
||||
|
||||
});
|
||||
|
||||
var __pika_web_default_export_for_treeshaking__ = /*@__PURE__*/getDefaultExportFromCjs(dist);
|
||||
|
||||
export default __pika_web_default_export_for_treeshaking__;
|
||||
344
docs/_snowpack/pkg/codemirror/lib/codemirror.css
vendored
344
docs/_snowpack/pkg/codemirror/lib/codemirror.css
vendored
@ -1,344 +0,0 @@
|
||||
/* BASICS */
|
||||
|
||||
.CodeMirror {
|
||||
/* Set height, width, borders, and global font properties here */
|
||||
font-family: monospace;
|
||||
height: 300px;
|
||||
color: black;
|
||||
direction: ltr;
|
||||
}
|
||||
|
||||
/* PADDING */
|
||||
|
||||
.CodeMirror-lines {
|
||||
padding: 4px 0; /* Vertical padding around content */
|
||||
}
|
||||
.CodeMirror pre.CodeMirror-line,
|
||||
.CodeMirror pre.CodeMirror-line-like {
|
||||
padding: 0 4px; /* Horizontal padding of content */
|
||||
}
|
||||
|
||||
.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
|
||||
background-color: white; /* The little square between H and V scrollbars */
|
||||
}
|
||||
|
||||
/* GUTTER */
|
||||
|
||||
.CodeMirror-gutters {
|
||||
border-right: 1px solid #ddd;
|
||||
background-color: #f7f7f7;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.CodeMirror-linenumbers {}
|
||||
.CodeMirror-linenumber {
|
||||
padding: 0 3px 0 5px;
|
||||
min-width: 20px;
|
||||
text-align: right;
|
||||
color: #999;
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.CodeMirror-guttermarker { color: black; }
|
||||
.CodeMirror-guttermarker-subtle { color: #999; }
|
||||
|
||||
/* CURSOR */
|
||||
|
||||
.CodeMirror-cursor {
|
||||
border-left: 1px solid black;
|
||||
border-right: none;
|
||||
width: 0;
|
||||
}
|
||||
/* Shown when moving in bi-directional text */
|
||||
.CodeMirror div.CodeMirror-secondarycursor {
|
||||
border-left: 1px solid silver;
|
||||
}
|
||||
.cm-fat-cursor .CodeMirror-cursor {
|
||||
width: auto;
|
||||
border: 0 !important;
|
||||
background: #7e7;
|
||||
}
|
||||
.cm-fat-cursor div.CodeMirror-cursors {
|
||||
z-index: 1;
|
||||
}
|
||||
.cm-fat-cursor .CodeMirror-line::selection,
|
||||
.cm-fat-cursor .CodeMirror-line > span::selection,
|
||||
.cm-fat-cursor .CodeMirror-line > span > span::selection { background: transparent; }
|
||||
.cm-fat-cursor .CodeMirror-line::-moz-selection,
|
||||
.cm-fat-cursor .CodeMirror-line > span::-moz-selection,
|
||||
.cm-fat-cursor .CodeMirror-line > span > span::-moz-selection { background: transparent; }
|
||||
.cm-fat-cursor { caret-color: transparent; }
|
||||
@-moz-keyframes blink {
|
||||
0% {}
|
||||
50% { background-color: transparent; }
|
||||
100% {}
|
||||
}
|
||||
@-webkit-keyframes blink {
|
||||
0% {}
|
||||
50% { background-color: transparent; }
|
||||
100% {}
|
||||
}
|
||||
@keyframes blink {
|
||||
0% {}
|
||||
50% { background-color: transparent; }
|
||||
100% {}
|
||||
}
|
||||
|
||||
/* Can style cursor different in overwrite (non-insert) mode */
|
||||
.CodeMirror-overwrite .CodeMirror-cursor {}
|
||||
|
||||
.cm-tab { display: inline-block; text-decoration: inherit; }
|
||||
|
||||
.CodeMirror-rulers {
|
||||
position: absolute;
|
||||
left: 0; right: 0; top: -50px; bottom: 0;
|
||||
overflow: hidden;
|
||||
}
|
||||
.CodeMirror-ruler {
|
||||
border-left: 1px solid #ccc;
|
||||
top: 0; bottom: 0;
|
||||
position: absolute;
|
||||
}
|
||||
|
||||
/* DEFAULT THEME */
|
||||
|
||||
.cm-s-default .cm-header {color: blue;}
|
||||
.cm-s-default .cm-quote {color: #090;}
|
||||
.cm-negative {color: #d44;}
|
||||
.cm-positive {color: #292;}
|
||||
.cm-header, .cm-strong {font-weight: bold;}
|
||||
.cm-em {font-style: italic;}
|
||||
.cm-link {text-decoration: underline;}
|
||||
.cm-strikethrough {text-decoration: line-through;}
|
||||
|
||||
.cm-s-default .cm-keyword {color: #708;}
|
||||
.cm-s-default .cm-atom {color: #219;}
|
||||
.cm-s-default .cm-number {color: #164;}
|
||||
.cm-s-default .cm-def {color: #00f;}
|
||||
.cm-s-default .cm-variable,
|
||||
.cm-s-default .cm-punctuation,
|
||||
.cm-s-default .cm-property,
|
||||
.cm-s-default .cm-operator {}
|
||||
.cm-s-default .cm-variable-2 {color: #05a;}
|
||||
.cm-s-default .cm-variable-3, .cm-s-default .cm-type {color: #085;}
|
||||
.cm-s-default .cm-comment {color: #a50;}
|
||||
.cm-s-default .cm-string {color: #a11;}
|
||||
.cm-s-default .cm-string-2 {color: #f50;}
|
||||
.cm-s-default .cm-meta {color: #555;}
|
||||
.cm-s-default .cm-qualifier {color: #555;}
|
||||
.cm-s-default .cm-builtin {color: #30a;}
|
||||
.cm-s-default .cm-bracket {color: #997;}
|
||||
.cm-s-default .cm-tag {color: #170;}
|
||||
.cm-s-default .cm-attribute {color: #00c;}
|
||||
.cm-s-default .cm-hr {color: #999;}
|
||||
.cm-s-default .cm-link {color: #00c;}
|
||||
|
||||
.cm-s-default .cm-error {color: #f00;}
|
||||
.cm-invalidchar {color: #f00;}
|
||||
|
||||
.CodeMirror-composing { border-bottom: 2px solid; }
|
||||
|
||||
/* Default styles for common addons */
|
||||
|
||||
div.CodeMirror span.CodeMirror-matchingbracket {color: #0b0;}
|
||||
div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #a22;}
|
||||
.CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }
|
||||
.CodeMirror-activeline-background {background: #e8f2ff;}
|
||||
|
||||
/* STOP */
|
||||
|
||||
/* The rest of this file contains styles related to the mechanics of
|
||||
the editor. You probably shouldn't touch them. */
|
||||
|
||||
.CodeMirror {
|
||||
position: relative;
|
||||
overflow: hidden;
|
||||
background: white;
|
||||
}
|
||||
|
||||
.CodeMirror-scroll {
|
||||
overflow: scroll !important; /* Things will break if this is overridden */
|
||||
/* 50px is the magic margin used to hide the element's real scrollbars */
|
||||
/* See overflow: hidden in .CodeMirror */
|
||||
margin-bottom: -50px; margin-right: -50px;
|
||||
padding-bottom: 50px;
|
||||
height: 100%;
|
||||
outline: none; /* Prevent dragging from highlighting the element */
|
||||
position: relative;
|
||||
z-index: 0;
|
||||
}
|
||||
.CodeMirror-sizer {
|
||||
position: relative;
|
||||
border-right: 50px solid transparent;
|
||||
}
|
||||
|
||||
/* The fake, visible scrollbars. Used to force redraw during scrolling
|
||||
before actual scrolling happens, thus preventing shaking and
|
||||
flickering artifacts. */
|
||||
.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
|
||||
position: absolute;
|
||||
z-index: 6;
|
||||
display: none;
|
||||
outline: none;
|
||||
}
|
||||
.CodeMirror-vscrollbar {
|
||||
right: 0; top: 0;
|
||||
overflow-x: hidden;
|
||||
overflow-y: scroll;
|
||||
}
|
||||
.CodeMirror-hscrollbar {
|
||||
bottom: 0; left: 0;
|
||||
overflow-y: hidden;
|
||||
overflow-x: scroll;
|
||||
}
|
||||
.CodeMirror-scrollbar-filler {
|
||||
right: 0; bottom: 0;
|
||||
}
|
||||
.CodeMirror-gutter-filler {
|
||||
left: 0; bottom: 0;
|
||||
}
|
||||
|
||||
.CodeMirror-gutters {
|
||||
position: absolute; left: 0; top: 0;
|
||||
min-height: 100%;
|
||||
z-index: 3;
|
||||
}
|
||||
.CodeMirror-gutter {
|
||||
white-space: normal;
|
||||
height: 100%;
|
||||
display: inline-block;
|
||||
vertical-align: top;
|
||||
margin-bottom: -50px;
|
||||
}
|
||||
.CodeMirror-gutter-wrapper {
|
||||
position: absolute;
|
||||
z-index: 4;
|
||||
background: none !important;
|
||||
border: none !important;
|
||||
}
|
||||
.CodeMirror-gutter-background {
|
||||
position: absolute;
|
||||
top: 0; bottom: 0;
|
||||
z-index: 4;
|
||||
}
|
||||
.CodeMirror-gutter-elt {
|
||||
position: absolute;
|
||||
cursor: default;
|
||||
z-index: 4;
|
||||
}
|
||||
.CodeMirror-gutter-wrapper ::selection { background-color: transparent }
|
||||
.CodeMirror-gutter-wrapper ::-moz-selection { background-color: transparent }
|
||||
|
||||
.CodeMirror-lines {
|
||||
cursor: text;
|
||||
min-height: 1px; /* prevents collapsing before first draw */
|
||||
}
|
||||
.CodeMirror pre.CodeMirror-line,
|
||||
.CodeMirror pre.CodeMirror-line-like {
|
||||
/* Reset some styles that the rest of the page might have set */
|
||||
-moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;
|
||||
border-width: 0;
|
||||
background: transparent;
|
||||
font-family: inherit;
|
||||
font-size: inherit;
|
||||
margin: 0;
|
||||
white-space: pre;
|
||||
word-wrap: normal;
|
||||
line-height: inherit;
|
||||
color: inherit;
|
||||
z-index: 2;
|
||||
position: relative;
|
||||
overflow: visible;
|
||||
-webkit-tap-highlight-color: transparent;
|
||||
-webkit-font-variant-ligatures: contextual;
|
||||
font-variant-ligatures: contextual;
|
||||
}
|
||||
.CodeMirror-wrap pre.CodeMirror-line,
|
||||
.CodeMirror-wrap pre.CodeMirror-line-like {
|
||||
word-wrap: break-word;
|
||||
white-space: pre-wrap;
|
||||
word-break: normal;
|
||||
}
|
||||
|
||||
.CodeMirror-linebackground {
|
||||
position: absolute;
|
||||
left: 0; right: 0; top: 0; bottom: 0;
|
||||
z-index: 0;
|
||||
}
|
||||
|
||||
.CodeMirror-linewidget {
|
||||
position: relative;
|
||||
z-index: 2;
|
||||
padding: 0.1px; /* Force widget margins to stay inside of the container */
|
||||
}
|
||||
|
||||
.CodeMirror-widget {}
|
||||
|
||||
.CodeMirror-rtl pre { direction: rtl; }
|
||||
|
||||
.CodeMirror-code {
|
||||
outline: none;
|
||||
}
|
||||
|
||||
/* Force content-box sizing for the elements where we expect it */
|
||||
.CodeMirror-scroll,
|
||||
.CodeMirror-sizer,
|
||||
.CodeMirror-gutter,
|
||||
.CodeMirror-gutters,
|
||||
.CodeMirror-linenumber {
|
||||
-moz-box-sizing: content-box;
|
||||
box-sizing: content-box;
|
||||
}
|
||||
|
||||
.CodeMirror-measure {
|
||||
position: absolute;
|
||||
width: 100%;
|
||||
height: 0;
|
||||
overflow: hidden;
|
||||
visibility: hidden;
|
||||
}
|
||||
|
||||
.CodeMirror-cursor {
|
||||
position: absolute;
|
||||
pointer-events: none;
|
||||
}
|
||||
.CodeMirror-measure pre { position: static; }
|
||||
|
||||
div.CodeMirror-cursors {
|
||||
visibility: hidden;
|
||||
position: relative;
|
||||
z-index: 3;
|
||||
}
|
||||
div.CodeMirror-dragcursors {
|
||||
visibility: visible;
|
||||
}
|
||||
|
||||
.CodeMirror-focused div.CodeMirror-cursors {
|
||||
visibility: visible;
|
||||
}
|
||||
|
||||
.CodeMirror-selected { background: #d9d9d9; }
|
||||
.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }
|
||||
.CodeMirror-crosshair { cursor: crosshair; }
|
||||
.CodeMirror-line::selection, .CodeMirror-line > span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; }
|
||||
.CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; }
|
||||
|
||||
.cm-searching {
|
||||
background-color: #ffa;
|
||||
background-color: rgba(255, 255, 0, .4);
|
||||
}
|
||||
|
||||
/* Used to force a border model for a node */
|
||||
.cm-force-border { padding-right: .1px; }
|
||||
|
||||
@media print {
|
||||
/* Hide the cursor when printing */
|
||||
.CodeMirror div.CodeMirror-cursors {
|
||||
visibility: hidden;
|
||||
}
|
||||
}
|
||||
|
||||
/* See issue #2901 */
|
||||
.cm-tab-wrap-hack:after { content: ''; }
|
||||
|
||||
/* Help users use markselection to safely style text background */
|
||||
span.CodeMirror-selectedtext { background: none; }
|
||||
File diff suppressed because one or more lines are too long
@ -1,960 +0,0 @@
|
||||
import { c as createCommonjsModule } from '../../../common/_commonjsHelpers-8c19dec8.js';
|
||||
import { c as codemirror } from '../../../common/codemirror-d650d44d.js';
|
||||
|
||||
var javascript = createCommonjsModule(function (module, exports) {
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: https://codemirror.net/LICENSE
|
||||
|
||||
(function(mod) {
|
||||
mod(codemirror);
|
||||
})(function(CodeMirror) {
|
||||
|
||||
CodeMirror.defineMode("javascript", function(config, parserConfig) {
|
||||
var indentUnit = config.indentUnit;
|
||||
var statementIndent = parserConfig.statementIndent;
|
||||
var jsonldMode = parserConfig.jsonld;
|
||||
var jsonMode = parserConfig.json || jsonldMode;
|
||||
var trackScope = parserConfig.trackScope !== false;
|
||||
var isTS = parserConfig.typescript;
|
||||
var wordRE = parserConfig.wordCharacters || /[\w$\xa1-\uffff]/;
|
||||
|
||||
// Tokenizer
|
||||
|
||||
var keywords = function(){
|
||||
function kw(type) {return {type: type, style: "keyword"};}
|
||||
var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c"), D = kw("keyword d");
|
||||
var operator = kw("operator"), atom = {type: "atom", style: "atom"};
|
||||
|
||||
return {
|
||||
"if": kw("if"), "while": A, "with": A, "else": B, "do": B, "try": B, "finally": B,
|
||||
"return": D, "break": D, "continue": D, "new": kw("new"), "delete": C, "void": C, "throw": C,
|
||||
"debugger": kw("debugger"), "var": kw("var"), "const": kw("var"), "let": kw("var"),
|
||||
"function": kw("function"), "catch": kw("catch"),
|
||||
"for": kw("for"), "switch": kw("switch"), "case": kw("case"), "default": kw("default"),
|
||||
"in": operator, "typeof": operator, "instanceof": operator,
|
||||
"true": atom, "false": atom, "null": atom, "undefined": atom, "NaN": atom, "Infinity": atom,
|
||||
"this": kw("this"), "class": kw("class"), "super": kw("atom"),
|
||||
"yield": C, "export": kw("export"), "import": kw("import"), "extends": C,
|
||||
"await": C
|
||||
};
|
||||
}();
|
||||
|
||||
var isOperatorChar = /[+\-*&%=<>!?|~^@]/;
|
||||
var isJsonldKeyword = /^@(context|id|value|language|type|container|list|set|reverse|index|base|vocab|graph)"/;
|
||||
|
||||
function readRegexp(stream) {
|
||||
var escaped = false, next, inSet = false;
|
||||
while ((next = stream.next()) != null) {
|
||||
if (!escaped) {
|
||||
if (next == "/" && !inSet) return;
|
||||
if (next == "[") inSet = true;
|
||||
else if (inSet && next == "]") inSet = false;
|
||||
}
|
||||
escaped = !escaped && next == "\\";
|
||||
}
|
||||
}
|
||||
|
||||
// Used as scratch variables to communicate multiple values without
|
||||
// consing up tons of objects.
|
||||
var type, content;
|
||||
function ret(tp, style, cont) {
|
||||
type = tp; content = cont;
|
||||
return style;
|
||||
}
|
||||
function tokenBase(stream, state) {
|
||||
var ch = stream.next();
|
||||
if (ch == '"' || ch == "'") {
|
||||
state.tokenize = tokenString(ch);
|
||||
return state.tokenize(stream, state);
|
||||
} else if (ch == "." && stream.match(/^\d[\d_]*(?:[eE][+\-]?[\d_]+)?/)) {
|
||||
return ret("number", "number");
|
||||
} else if (ch == "." && stream.match("..")) {
|
||||
return ret("spread", "meta");
|
||||
} else if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
|
||||
return ret(ch);
|
||||
} else if (ch == "=" && stream.eat(">")) {
|
||||
return ret("=>", "operator");
|
||||
} else if (ch == "0" && stream.match(/^(?:x[\dA-Fa-f_]+|o[0-7_]+|b[01_]+)n?/)) {
|
||||
return ret("number", "number");
|
||||
} else if (/\d/.test(ch)) {
|
||||
stream.match(/^[\d_]*(?:n|(?:\.[\d_]*)?(?:[eE][+\-]?[\d_]+)?)?/);
|
||||
return ret("number", "number");
|
||||
} else if (ch == "/") {
|
||||
if (stream.eat("*")) {
|
||||
state.tokenize = tokenComment;
|
||||
return tokenComment(stream, state);
|
||||
} else if (stream.eat("/")) {
|
||||
stream.skipToEnd();
|
||||
return ret("comment", "comment");
|
||||
} else if (expressionAllowed(stream, state, 1)) {
|
||||
readRegexp(stream);
|
||||
stream.match(/^\b(([gimyus])(?![gimyus]*\2))+\b/);
|
||||
return ret("regexp", "string-2");
|
||||
} else {
|
||||
stream.eat("=");
|
||||
return ret("operator", "operator", stream.current());
|
||||
}
|
||||
} else if (ch == "`") {
|
||||
state.tokenize = tokenQuasi;
|
||||
return tokenQuasi(stream, state);
|
||||
} else if (ch == "#" && stream.peek() == "!") {
|
||||
stream.skipToEnd();
|
||||
return ret("meta", "meta");
|
||||
} else if (ch == "#" && stream.eatWhile(wordRE)) {
|
||||
return ret("variable", "property")
|
||||
} else if (ch == "<" && stream.match("!--") ||
|
||||
(ch == "-" && stream.match("->") && !/\S/.test(stream.string.slice(0, stream.start)))) {
|
||||
stream.skipToEnd();
|
||||
return ret("comment", "comment")
|
||||
} else if (isOperatorChar.test(ch)) {
|
||||
if (ch != ">" || !state.lexical || state.lexical.type != ">") {
|
||||
if (stream.eat("=")) {
|
||||
if (ch == "!" || ch == "=") stream.eat("=");
|
||||
} else if (/[<>*+\-|&?]/.test(ch)) {
|
||||
stream.eat(ch);
|
||||
if (ch == ">") stream.eat(ch);
|
||||
}
|
||||
}
|
||||
if (ch == "?" && stream.eat(".")) return ret(".")
|
||||
return ret("operator", "operator", stream.current());
|
||||
} else if (wordRE.test(ch)) {
|
||||
stream.eatWhile(wordRE);
|
||||
var word = stream.current();
|
||||
if (state.lastType != ".") {
|
||||
if (keywords.propertyIsEnumerable(word)) {
|
||||
var kw = keywords[word];
|
||||
return ret(kw.type, kw.style, word)
|
||||
}
|
||||
if (word == "async" && stream.match(/^(\s|\/\*([^*]|\*(?!\/))*?\*\/)*[\[\(\w]/, false))
|
||||
return ret("async", "keyword", word)
|
||||
}
|
||||
return ret("variable", "variable", word)
|
||||
}
|
||||
}
|
||||
|
||||
function tokenString(quote) {
|
||||
return function(stream, state) {
|
||||
var escaped = false, next;
|
||||
if (jsonldMode && stream.peek() == "@" && stream.match(isJsonldKeyword)){
|
||||
state.tokenize = tokenBase;
|
||||
return ret("jsonld-keyword", "meta");
|
||||
}
|
||||
while ((next = stream.next()) != null) {
|
||||
if (next == quote && !escaped) break;
|
||||
escaped = !escaped && next == "\\";
|
||||
}
|
||||
if (!escaped) state.tokenize = tokenBase;
|
||||
return ret("string", "string");
|
||||
};
|
||||
}
|
||||
|
||||
function tokenComment(stream, state) {
|
||||
var maybeEnd = false, ch;
|
||||
while (ch = stream.next()) {
|
||||
if (ch == "/" && maybeEnd) {
|
||||
state.tokenize = tokenBase;
|
||||
break;
|
||||
}
|
||||
maybeEnd = (ch == "*");
|
||||
}
|
||||
return ret("comment", "comment");
|
||||
}
|
||||
|
||||
function tokenQuasi(stream, state) {
|
||||
var escaped = false, next;
|
||||
while ((next = stream.next()) != null) {
|
||||
if (!escaped && (next == "`" || next == "$" && stream.eat("{"))) {
|
||||
state.tokenize = tokenBase;
|
||||
break;
|
||||
}
|
||||
escaped = !escaped && next == "\\";
|
||||
}
|
||||
return ret("quasi", "string-2", stream.current());
|
||||
}
|
||||
|
||||
var brackets = "([{}])";
|
||||
// This is a crude lookahead trick to try and notice that we're
|
||||
// parsing the argument patterns for a fat-arrow function before we
|
||||
// actually hit the arrow token. It only works if the arrow is on
|
||||
// the same line as the arguments and there's no strange noise
|
||||
// (comments) in between. Fallback is to only notice when we hit the
|
||||
// arrow, and not declare the arguments as locals for the arrow
|
||||
// body.
|
||||
function findFatArrow(stream, state) {
|
||||
if (state.fatArrowAt) state.fatArrowAt = null;
|
||||
var arrow = stream.string.indexOf("=>", stream.start);
|
||||
if (arrow < 0) return;
|
||||
|
||||
if (isTS) { // Try to skip TypeScript return type declarations after the arguments
|
||||
var m = /:\s*(?:\w+(?:<[^>]*>|\[\])?|\{[^}]*\})\s*$/.exec(stream.string.slice(stream.start, arrow));
|
||||
if (m) arrow = m.index;
|
||||
}
|
||||
|
||||
var depth = 0, sawSomething = false;
|
||||
for (var pos = arrow - 1; pos >= 0; --pos) {
|
||||
var ch = stream.string.charAt(pos);
|
||||
var bracket = brackets.indexOf(ch);
|
||||
if (bracket >= 0 && bracket < 3) {
|
||||
if (!depth) { ++pos; break; }
|
||||
if (--depth == 0) { if (ch == "(") sawSomething = true; break; }
|
||||
} else if (bracket >= 3 && bracket < 6) {
|
||||
++depth;
|
||||
} else if (wordRE.test(ch)) {
|
||||
sawSomething = true;
|
||||
} else if (/["'\/`]/.test(ch)) {
|
||||
for (;; --pos) {
|
||||
if (pos == 0) return
|
||||
var next = stream.string.charAt(pos - 1);
|
||||
if (next == ch && stream.string.charAt(pos - 2) != "\\") { pos--; break }
|
||||
}
|
||||
} else if (sawSomething && !depth) {
|
||||
++pos;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (sawSomething && !depth) state.fatArrowAt = pos;
|
||||
}
|
||||
|
||||
// Parser
|
||||
|
||||
var atomicTypes = {"atom": true, "number": true, "variable": true, "string": true,
|
||||
"regexp": true, "this": true, "import": true, "jsonld-keyword": true};
|
||||
|
||||
function JSLexical(indented, column, type, align, prev, info) {
|
||||
this.indented = indented;
|
||||
this.column = column;
|
||||
this.type = type;
|
||||
this.prev = prev;
|
||||
this.info = info;
|
||||
if (align != null) this.align = align;
|
||||
}
|
||||
|
||||
function inScope(state, varname) {
|
||||
if (!trackScope) return false
|
||||
for (var v = state.localVars; v; v = v.next)
|
||||
if (v.name == varname) return true;
|
||||
for (var cx = state.context; cx; cx = cx.prev) {
|
||||
for (var v = cx.vars; v; v = v.next)
|
||||
if (v.name == varname) return true;
|
||||
}
|
||||
}
|
||||
|
||||
function parseJS(state, style, type, content, stream) {
|
||||
var cc = state.cc;
|
||||
// Communicate our context to the combinators.
|
||||
// (Less wasteful than consing up a hundred closures on every call.)
|
||||
cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc; cx.style = style;
|
||||
|
||||
if (!state.lexical.hasOwnProperty("align"))
|
||||
state.lexical.align = true;
|
||||
|
||||
while(true) {
|
||||
var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;
|
||||
if (combinator(type, content)) {
|
||||
while(cc.length && cc[cc.length - 1].lex)
|
||||
cc.pop()();
|
||||
if (cx.marked) return cx.marked;
|
||||
if (type == "variable" && inScope(state, content)) return "variable-2";
|
||||
return style;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Combinator utils
|
||||
|
||||
var cx = {state: null, column: null, marked: null, cc: null};
|
||||
function pass() {
|
||||
for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]);
|
||||
}
|
||||
function cont() {
|
||||
pass.apply(null, arguments);
|
||||
return true;
|
||||
}
|
||||
function inList(name, list) {
|
||||
for (var v = list; v; v = v.next) if (v.name == name) return true
|
||||
return false;
|
||||
}
|
||||
function register(varname) {
|
||||
var state = cx.state;
|
||||
cx.marked = "def";
|
||||
if (!trackScope) return
|
||||
if (state.context) {
|
||||
if (state.lexical.info == "var" && state.context && state.context.block) {
|
||||
// FIXME function decls are also not block scoped
|
||||
var newContext = registerVarScoped(varname, state.context);
|
||||
if (newContext != null) {
|
||||
state.context = newContext;
|
||||
return
|
||||
}
|
||||
} else if (!inList(varname, state.localVars)) {
|
||||
state.localVars = new Var(varname, state.localVars);
|
||||
return
|
||||
}
|
||||
}
|
||||
// Fall through means this is global
|
||||
if (parserConfig.globalVars && !inList(varname, state.globalVars))
|
||||
state.globalVars = new Var(varname, state.globalVars);
|
||||
}
|
||||
function registerVarScoped(varname, context) {
|
||||
if (!context) {
|
||||
return null
|
||||
} else if (context.block) {
|
||||
var inner = registerVarScoped(varname, context.prev);
|
||||
if (!inner) return null
|
||||
if (inner == context.prev) return context
|
||||
return new Context(inner, context.vars, true)
|
||||
} else if (inList(varname, context.vars)) {
|
||||
return context
|
||||
} else {
|
||||
return new Context(context.prev, new Var(varname, context.vars), false)
|
||||
}
|
||||
}
|
||||
|
||||
function isModifier(name) {
|
||||
return name == "public" || name == "private" || name == "protected" || name == "abstract" || name == "readonly"
|
||||
}
|
||||
|
||||
// Combinators
|
||||
|
||||
function Context(prev, vars, block) { this.prev = prev; this.vars = vars; this.block = block; }
|
||||
function Var(name, next) { this.name = name; this.next = next; }
|
||||
|
||||
var defaultVars = new Var("this", new Var("arguments", null));
|
||||
function pushcontext() {
|
||||
cx.state.context = new Context(cx.state.context, cx.state.localVars, false);
|
||||
cx.state.localVars = defaultVars;
|
||||
}
|
||||
function pushblockcontext() {
|
||||
cx.state.context = new Context(cx.state.context, cx.state.localVars, true);
|
||||
cx.state.localVars = null;
|
||||
}
|
||||
pushcontext.lex = pushblockcontext.lex = true;
|
||||
function popcontext() {
|
||||
cx.state.localVars = cx.state.context.vars;
|
||||
cx.state.context = cx.state.context.prev;
|
||||
}
|
||||
popcontext.lex = true;
|
||||
function pushlex(type, info) {
|
||||
var result = function() {
|
||||
var state = cx.state, indent = state.indented;
|
||||
if (state.lexical.type == "stat") indent = state.lexical.indented;
|
||||
else for (var outer = state.lexical; outer && outer.type == ")" && outer.align; outer = outer.prev)
|
||||
indent = outer.indented;
|
||||
state.lexical = new JSLexical(indent, cx.stream.column(), type, null, state.lexical, info);
|
||||
};
|
||||
result.lex = true;
|
||||
return result;
|
||||
}
|
||||
function poplex() {
|
||||
var state = cx.state;
|
||||
if (state.lexical.prev) {
|
||||
if (state.lexical.type == ")")
|
||||
state.indented = state.lexical.indented;
|
||||
state.lexical = state.lexical.prev;
|
||||
}
|
||||
}
|
||||
poplex.lex = true;
|
||||
|
||||
function expect(wanted) {
|
||||
function exp(type) {
|
||||
if (type == wanted) return cont();
|
||||
else if (wanted == ";" || type == "}" || type == ")" || type == "]") return pass();
|
||||
else return cont(exp);
|
||||
} return exp;
|
||||
}
|
||||
|
||||
function statement(type, value) {
|
||||
if (type == "var") return cont(pushlex("vardef", value), vardef, expect(";"), poplex);
|
||||
if (type == "keyword a") return cont(pushlex("form"), parenExpr, statement, poplex);
|
||||
if (type == "keyword b") return cont(pushlex("form"), statement, poplex);
|
||||
if (type == "keyword d") return cx.stream.match(/^\s*$/, false) ? cont() : cont(pushlex("stat"), maybeexpression, expect(";"), poplex);
|
||||
if (type == "debugger") return cont(expect(";"));
|
||||
if (type == "{") return cont(pushlex("}"), pushblockcontext, block, poplex, popcontext);
|
||||
if (type == ";") return cont();
|
||||
if (type == "if") {
|
||||
if (cx.state.lexical.info == "else" && cx.state.cc[cx.state.cc.length - 1] == poplex)
|
||||
cx.state.cc.pop()();
|
||||
return cont(pushlex("form"), parenExpr, statement, poplex, maybeelse);
|
||||
}
|
||||
if (type == "function") return cont(functiondef);
|
||||
if (type == "for") return cont(pushlex("form"), pushblockcontext, forspec, statement, popcontext, poplex);
|
||||
if (type == "class" || (isTS && value == "interface")) {
|
||||
cx.marked = "keyword";
|
||||
return cont(pushlex("form", type == "class" ? type : value), className, poplex)
|
||||
}
|
||||
if (type == "variable") {
|
||||
if (isTS && value == "declare") {
|
||||
cx.marked = "keyword";
|
||||
return cont(statement)
|
||||
} else if (isTS && (value == "module" || value == "enum" || value == "type") && cx.stream.match(/^\s*\w/, false)) {
|
||||
cx.marked = "keyword";
|
||||
if (value == "enum") return cont(enumdef);
|
||||
else if (value == "type") return cont(typename, expect("operator"), typeexpr, expect(";"));
|
||||
else return cont(pushlex("form"), pattern, expect("{"), pushlex("}"), block, poplex, poplex)
|
||||
} else if (isTS && value == "namespace") {
|
||||
cx.marked = "keyword";
|
||||
return cont(pushlex("form"), expression, statement, poplex)
|
||||
} else if (isTS && value == "abstract") {
|
||||
cx.marked = "keyword";
|
||||
return cont(statement)
|
||||
} else {
|
||||
return cont(pushlex("stat"), maybelabel);
|
||||
}
|
||||
}
|
||||
if (type == "switch") return cont(pushlex("form"), parenExpr, expect("{"), pushlex("}", "switch"), pushblockcontext,
|
||||
block, poplex, poplex, popcontext);
|
||||
if (type == "case") return cont(expression, expect(":"));
|
||||
if (type == "default") return cont(expect(":"));
|
||||
if (type == "catch") return cont(pushlex("form"), pushcontext, maybeCatchBinding, statement, poplex, popcontext);
|
||||
if (type == "export") return cont(pushlex("stat"), afterExport, poplex);
|
||||
if (type == "import") return cont(pushlex("stat"), afterImport, poplex);
|
||||
if (type == "async") return cont(statement)
|
||||
if (value == "@") return cont(expression, statement)
|
||||
return pass(pushlex("stat"), expression, expect(";"), poplex);
|
||||
}
|
||||
function maybeCatchBinding(type) {
|
||||
if (type == "(") return cont(funarg, expect(")"))
|
||||
}
|
||||
function expression(type, value) {
|
||||
return expressionInner(type, value, false);
|
||||
}
|
||||
function expressionNoComma(type, value) {
|
||||
return expressionInner(type, value, true);
|
||||
}
|
||||
function parenExpr(type) {
|
||||
if (type != "(") return pass()
|
||||
return cont(pushlex(")"), maybeexpression, expect(")"), poplex)
|
||||
}
|
||||
function expressionInner(type, value, noComma) {
|
||||
if (cx.state.fatArrowAt == cx.stream.start) {
|
||||
var body = noComma ? arrowBodyNoComma : arrowBody;
|
||||
if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, expect("=>"), body, popcontext);
|
||||
else if (type == "variable") return pass(pushcontext, pattern, expect("=>"), body, popcontext);
|
||||
}
|
||||
|
||||
var maybeop = noComma ? maybeoperatorNoComma : maybeoperatorComma;
|
||||
if (atomicTypes.hasOwnProperty(type)) return cont(maybeop);
|
||||
if (type == "function") return cont(functiondef, maybeop);
|
||||
if (type == "class" || (isTS && value == "interface")) { cx.marked = "keyword"; return cont(pushlex("form"), classExpression, poplex); }
|
||||
if (type == "keyword c" || type == "async") return cont(noComma ? expressionNoComma : expression);
|
||||
if (type == "(") return cont(pushlex(")"), maybeexpression, expect(")"), poplex, maybeop);
|
||||
if (type == "operator" || type == "spread") return cont(noComma ? expressionNoComma : expression);
|
||||
if (type == "[") return cont(pushlex("]"), arrayLiteral, poplex, maybeop);
|
||||
if (type == "{") return contCommasep(objprop, "}", null, maybeop);
|
||||
if (type == "quasi") return pass(quasi, maybeop);
|
||||
if (type == "new") return cont(maybeTarget(noComma));
|
||||
return cont();
|
||||
}
|
||||
function maybeexpression(type) {
|
||||
if (type.match(/[;\}\)\],]/)) return pass();
|
||||
return pass(expression);
|
||||
}
|
||||
|
||||
function maybeoperatorComma(type, value) {
|
||||
if (type == ",") return cont(maybeexpression);
|
||||
return maybeoperatorNoComma(type, value, false);
|
||||
}
|
||||
function maybeoperatorNoComma(type, value, noComma) {
|
||||
var me = noComma == false ? maybeoperatorComma : maybeoperatorNoComma;
|
||||
var expr = noComma == false ? expression : expressionNoComma;
|
||||
if (type == "=>") return cont(pushcontext, noComma ? arrowBodyNoComma : arrowBody, popcontext);
|
||||
if (type == "operator") {
|
||||
if (/\+\+|--/.test(value) || isTS && value == "!") return cont(me);
|
||||
if (isTS && value == "<" && cx.stream.match(/^([^<>]|<[^<>]*>)*>\s*\(/, false))
|
||||
return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, me);
|
||||
if (value == "?") return cont(expression, expect(":"), expr);
|
||||
return cont(expr);
|
||||
}
|
||||
if (type == "quasi") { return pass(quasi, me); }
|
||||
if (type == ";") return;
|
||||
if (type == "(") return contCommasep(expressionNoComma, ")", "call", me);
|
||||
if (type == ".") return cont(property, me);
|
||||
if (type == "[") return cont(pushlex("]"), maybeexpression, expect("]"), poplex, me);
|
||||
if (isTS && value == "as") { cx.marked = "keyword"; return cont(typeexpr, me) }
|
||||
if (type == "regexp") {
|
||||
cx.state.lastType = cx.marked = "operator";
|
||||
cx.stream.backUp(cx.stream.pos - cx.stream.start - 1);
|
||||
return cont(expr)
|
||||
}
|
||||
}
|
||||
function quasi(type, value) {
|
||||
if (type != "quasi") return pass();
|
||||
if (value.slice(value.length - 2) != "${") return cont(quasi);
|
||||
return cont(maybeexpression, continueQuasi);
|
||||
}
|
||||
function continueQuasi(type) {
|
||||
if (type == "}") {
|
||||
cx.marked = "string-2";
|
||||
cx.state.tokenize = tokenQuasi;
|
||||
return cont(quasi);
|
||||
}
|
||||
}
|
||||
function arrowBody(type) {
|
||||
findFatArrow(cx.stream, cx.state);
|
||||
return pass(type == "{" ? statement : expression);
|
||||
}
|
||||
function arrowBodyNoComma(type) {
|
||||
findFatArrow(cx.stream, cx.state);
|
||||
return pass(type == "{" ? statement : expressionNoComma);
|
||||
}
|
||||
function maybeTarget(noComma) {
|
||||
return function(type) {
|
||||
if (type == ".") return cont(noComma ? targetNoComma : target);
|
||||
else if (type == "variable" && isTS) return cont(maybeTypeArgs, noComma ? maybeoperatorNoComma : maybeoperatorComma)
|
||||
else return pass(noComma ? expressionNoComma : expression);
|
||||
};
|
||||
}
|
||||
function target(_, value) {
|
||||
if (value == "target") { cx.marked = "keyword"; return cont(maybeoperatorComma); }
|
||||
}
|
||||
function targetNoComma(_, value) {
|
||||
if (value == "target") { cx.marked = "keyword"; return cont(maybeoperatorNoComma); }
|
||||
}
|
||||
function maybelabel(type) {
|
||||
if (type == ":") return cont(poplex, statement);
|
||||
return pass(maybeoperatorComma, expect(";"), poplex);
|
||||
}
|
||||
function property(type) {
|
||||
if (type == "variable") {cx.marked = "property"; return cont();}
|
||||
}
|
||||
function objprop(type, value) {
|
||||
if (type == "async") {
|
||||
cx.marked = "property";
|
||||
return cont(objprop);
|
||||
} else if (type == "variable" || cx.style == "keyword") {
|
||||
cx.marked = "property";
|
||||
if (value == "get" || value == "set") return cont(getterSetter);
|
||||
var m; // Work around fat-arrow-detection complication for detecting typescript typed arrow params
|
||||
if (isTS && cx.state.fatArrowAt == cx.stream.start && (m = cx.stream.match(/^\s*:\s*/, false)))
|
||||
cx.state.fatArrowAt = cx.stream.pos + m[0].length;
|
||||
return cont(afterprop);
|
||||
} else if (type == "number" || type == "string") {
|
||||
cx.marked = jsonldMode ? "property" : (cx.style + " property");
|
||||
return cont(afterprop);
|
||||
} else if (type == "jsonld-keyword") {
|
||||
return cont(afterprop);
|
||||
} else if (isTS && isModifier(value)) {
|
||||
cx.marked = "keyword";
|
||||
return cont(objprop)
|
||||
} else if (type == "[") {
|
||||
return cont(expression, maybetype, expect("]"), afterprop);
|
||||
} else if (type == "spread") {
|
||||
return cont(expressionNoComma, afterprop);
|
||||
} else if (value == "*") {
|
||||
cx.marked = "keyword";
|
||||
return cont(objprop);
|
||||
} else if (type == ":") {
|
||||
return pass(afterprop)
|
||||
}
|
||||
}
|
||||
function getterSetter(type) {
|
||||
if (type != "variable") return pass(afterprop);
|
||||
cx.marked = "property";
|
||||
return cont(functiondef);
|
||||
}
|
||||
function afterprop(type) {
|
||||
if (type == ":") return cont(expressionNoComma);
|
||||
if (type == "(") return pass(functiondef);
|
||||
}
|
||||
function commasep(what, end, sep) {
|
||||
function proceed(type, value) {
|
||||
if (sep ? sep.indexOf(type) > -1 : type == ",") {
|
||||
var lex = cx.state.lexical;
|
||||
if (lex.info == "call") lex.pos = (lex.pos || 0) + 1;
|
||||
return cont(function(type, value) {
|
||||
if (type == end || value == end) return pass()
|
||||
return pass(what)
|
||||
}, proceed);
|
||||
}
|
||||
if (type == end || value == end) return cont();
|
||||
if (sep && sep.indexOf(";") > -1) return pass(what)
|
||||
return cont(expect(end));
|
||||
}
|
||||
return function(type, value) {
|
||||
if (type == end || value == end) return cont();
|
||||
return pass(what, proceed);
|
||||
};
|
||||
}
|
||||
function contCommasep(what, end, info) {
|
||||
for (var i = 3; i < arguments.length; i++)
|
||||
cx.cc.push(arguments[i]);
|
||||
return cont(pushlex(end, info), commasep(what, end), poplex);
|
||||
}
|
||||
function block(type) {
|
||||
if (type == "}") return cont();
|
||||
return pass(statement, block);
|
||||
}
|
||||
function maybetype(type, value) {
|
||||
if (isTS) {
|
||||
if (type == ":") return cont(typeexpr);
|
||||
if (value == "?") return cont(maybetype);
|
||||
}
|
||||
}
|
||||
function maybetypeOrIn(type, value) {
|
||||
if (isTS && (type == ":" || value == "in")) return cont(typeexpr)
|
||||
}
|
||||
function mayberettype(type) {
|
||||
if (isTS && type == ":") {
|
||||
if (cx.stream.match(/^\s*\w+\s+is\b/, false)) return cont(expression, isKW, typeexpr)
|
||||
else return cont(typeexpr)
|
||||
}
|
||||
}
|
||||
function isKW(_, value) {
|
||||
if (value == "is") {
|
||||
cx.marked = "keyword";
|
||||
return cont()
|
||||
}
|
||||
}
|
||||
function typeexpr(type, value) {
|
||||
if (value == "keyof" || value == "typeof" || value == "infer" || value == "readonly") {
|
||||
cx.marked = "keyword";
|
||||
return cont(value == "typeof" ? expressionNoComma : typeexpr)
|
||||
}
|
||||
if (type == "variable" || value == "void") {
|
||||
cx.marked = "type";
|
||||
return cont(afterType)
|
||||
}
|
||||
if (value == "|" || value == "&") return cont(typeexpr)
|
||||
if (type == "string" || type == "number" || type == "atom") return cont(afterType);
|
||||
if (type == "[") return cont(pushlex("]"), commasep(typeexpr, "]", ","), poplex, afterType)
|
||||
if (type == "{") return cont(pushlex("}"), typeprops, poplex, afterType)
|
||||
if (type == "(") return cont(commasep(typearg, ")"), maybeReturnType, afterType)
|
||||
if (type == "<") return cont(commasep(typeexpr, ">"), typeexpr)
|
||||
if (type == "quasi") { return pass(quasiType, afterType); }
|
||||
}
|
||||
function maybeReturnType(type) {
|
||||
if (type == "=>") return cont(typeexpr)
|
||||
}
|
||||
function typeprops(type) {
|
||||
if (type.match(/[\}\)\]]/)) return cont()
|
||||
if (type == "," || type == ";") return cont(typeprops)
|
||||
return pass(typeprop, typeprops)
|
||||
}
|
||||
function typeprop(type, value) {
|
||||
if (type == "variable" || cx.style == "keyword") {
|
||||
cx.marked = "property";
|
||||
return cont(typeprop)
|
||||
} else if (value == "?" || type == "number" || type == "string") {
|
||||
return cont(typeprop)
|
||||
} else if (type == ":") {
|
||||
return cont(typeexpr)
|
||||
} else if (type == "[") {
|
||||
return cont(expect("variable"), maybetypeOrIn, expect("]"), typeprop)
|
||||
} else if (type == "(") {
|
||||
return pass(functiondecl, typeprop)
|
||||
} else if (!type.match(/[;\}\)\],]/)) {
|
||||
return cont()
|
||||
}
|
||||
}
|
||||
function quasiType(type, value) {
|
||||
if (type != "quasi") return pass();
|
||||
if (value.slice(value.length - 2) != "${") return cont(quasiType);
|
||||
return cont(typeexpr, continueQuasiType);
|
||||
}
|
||||
function continueQuasiType(type) {
|
||||
if (type == "}") {
|
||||
cx.marked = "string-2";
|
||||
cx.state.tokenize = tokenQuasi;
|
||||
return cont(quasiType);
|
||||
}
|
||||
}
|
||||
function typearg(type, value) {
|
||||
if (type == "variable" && cx.stream.match(/^\s*[?:]/, false) || value == "?") return cont(typearg)
|
||||
if (type == ":") return cont(typeexpr)
|
||||
if (type == "spread") return cont(typearg)
|
||||
return pass(typeexpr)
|
||||
}
|
||||
function afterType(type, value) {
|
||||
if (value == "<") return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, afterType)
|
||||
if (value == "|" || type == "." || value == "&") return cont(typeexpr)
|
||||
if (type == "[") return cont(typeexpr, expect("]"), afterType)
|
||||
if (value == "extends" || value == "implements") { cx.marked = "keyword"; return cont(typeexpr) }
|
||||
if (value == "?") return cont(typeexpr, expect(":"), typeexpr)
|
||||
}
|
||||
function maybeTypeArgs(_, value) {
|
||||
if (value == "<") return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, afterType)
|
||||
}
|
||||
function typeparam() {
|
||||
return pass(typeexpr, maybeTypeDefault)
|
||||
}
|
||||
function maybeTypeDefault(_, value) {
|
||||
if (value == "=") return cont(typeexpr)
|
||||
}
|
||||
function vardef(_, value) {
|
||||
if (value == "enum") {cx.marked = "keyword"; return cont(enumdef)}
|
||||
return pass(pattern, maybetype, maybeAssign, vardefCont);
|
||||
}
|
||||
function pattern(type, value) {
|
||||
if (isTS && isModifier(value)) { cx.marked = "keyword"; return cont(pattern) }
|
||||
if (type == "variable") { register(value); return cont(); }
|
||||
if (type == "spread") return cont(pattern);
|
||||
if (type == "[") return contCommasep(eltpattern, "]");
|
||||
if (type == "{") return contCommasep(proppattern, "}");
|
||||
}
|
||||
function proppattern(type, value) {
|
||||
if (type == "variable" && !cx.stream.match(/^\s*:/, false)) {
|
||||
register(value);
|
||||
return cont(maybeAssign);
|
||||
}
|
||||
if (type == "variable") cx.marked = "property";
|
||||
if (type == "spread") return cont(pattern);
|
||||
if (type == "}") return pass();
|
||||
if (type == "[") return cont(expression, expect(']'), expect(':'), proppattern);
|
||||
return cont(expect(":"), pattern, maybeAssign);
|
||||
}
|
||||
function eltpattern() {
|
||||
return pass(pattern, maybeAssign)
|
||||
}
|
||||
function maybeAssign(_type, value) {
|
||||
if (value == "=") return cont(expressionNoComma);
|
||||
}
|
||||
function vardefCont(type) {
|
||||
if (type == ",") return cont(vardef);
|
||||
}
|
||||
function maybeelse(type, value) {
|
||||
if (type == "keyword b" && value == "else") return cont(pushlex("form", "else"), statement, poplex);
|
||||
}
|
||||
function forspec(type, value) {
|
||||
if (value == "await") return cont(forspec);
|
||||
if (type == "(") return cont(pushlex(")"), forspec1, poplex);
|
||||
}
|
||||
function forspec1(type) {
|
||||
if (type == "var") return cont(vardef, forspec2);
|
||||
if (type == "variable") return cont(forspec2);
|
||||
return pass(forspec2)
|
||||
}
|
||||
function forspec2(type, value) {
|
||||
if (type == ")") return cont()
|
||||
if (type == ";") return cont(forspec2)
|
||||
if (value == "in" || value == "of") { cx.marked = "keyword"; return cont(expression, forspec2) }
|
||||
return pass(expression, forspec2)
|
||||
}
|
||||
function functiondef(type, value) {
|
||||
if (value == "*") {cx.marked = "keyword"; return cont(functiondef);}
|
||||
if (type == "variable") {register(value); return cont(functiondef);}
|
||||
if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, mayberettype, statement, popcontext);
|
||||
if (isTS && value == "<") return cont(pushlex(">"), commasep(typeparam, ">"), poplex, functiondef)
|
||||
}
|
||||
function functiondecl(type, value) {
|
||||
if (value == "*") {cx.marked = "keyword"; return cont(functiondecl);}
|
||||
if (type == "variable") {register(value); return cont(functiondecl);}
|
||||
if (type == "(") return cont(pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, mayberettype, popcontext);
|
||||
if (isTS && value == "<") return cont(pushlex(">"), commasep(typeparam, ">"), poplex, functiondecl)
|
||||
}
|
||||
function typename(type, value) {
|
||||
if (type == "keyword" || type == "variable") {
|
||||
cx.marked = "type";
|
||||
return cont(typename)
|
||||
} else if (value == "<") {
|
||||
return cont(pushlex(">"), commasep(typeparam, ">"), poplex)
|
||||
}
|
||||
}
|
||||
function funarg(type, value) {
|
||||
if (value == "@") cont(expression, funarg);
|
||||
if (type == "spread") return cont(funarg);
|
||||
if (isTS && isModifier(value)) { cx.marked = "keyword"; return cont(funarg); }
|
||||
if (isTS && type == "this") return cont(maybetype, maybeAssign)
|
||||
return pass(pattern, maybetype, maybeAssign);
|
||||
}
|
||||
function classExpression(type, value) {
|
||||
// Class expressions may have an optional name.
|
||||
if (type == "variable") return className(type, value);
|
||||
return classNameAfter(type, value);
|
||||
}
|
||||
function className(type, value) {
|
||||
if (type == "variable") {register(value); return cont(classNameAfter);}
|
||||
}
|
||||
function classNameAfter(type, value) {
|
||||
if (value == "<") return cont(pushlex(">"), commasep(typeparam, ">"), poplex, classNameAfter)
|
||||
if (value == "extends" || value == "implements" || (isTS && type == ",")) {
|
||||
if (value == "implements") cx.marked = "keyword";
|
||||
return cont(isTS ? typeexpr : expression, classNameAfter);
|
||||
}
|
||||
if (type == "{") return cont(pushlex("}"), classBody, poplex);
|
||||
}
|
||||
function classBody(type, value) {
|
||||
if (type == "async" ||
|
||||
(type == "variable" &&
|
||||
(value == "static" || value == "get" || value == "set" || (isTS && isModifier(value))) &&
|
||||
cx.stream.match(/^\s+[\w$\xa1-\uffff]/, false))) {
|
||||
cx.marked = "keyword";
|
||||
return cont(classBody);
|
||||
}
|
||||
if (type == "variable" || cx.style == "keyword") {
|
||||
cx.marked = "property";
|
||||
return cont(classfield, classBody);
|
||||
}
|
||||
if (type == "number" || type == "string") return cont(classfield, classBody);
|
||||
if (type == "[")
|
||||
return cont(expression, maybetype, expect("]"), classfield, classBody)
|
||||
if (value == "*") {
|
||||
cx.marked = "keyword";
|
||||
return cont(classBody);
|
||||
}
|
||||
if (isTS && type == "(") return pass(functiondecl, classBody)
|
||||
if (type == ";" || type == ",") return cont(classBody);
|
||||
if (type == "}") return cont();
|
||||
if (value == "@") return cont(expression, classBody)
|
||||
}
|
||||
function classfield(type, value) {
|
||||
if (value == "!") return cont(classfield)
|
||||
if (value == "?") return cont(classfield)
|
||||
if (type == ":") return cont(typeexpr, maybeAssign)
|
||||
if (value == "=") return cont(expressionNoComma)
|
||||
var context = cx.state.lexical.prev, isInterface = context && context.info == "interface";
|
||||
return pass(isInterface ? functiondecl : functiondef)
|
||||
}
|
||||
function afterExport(type, value) {
|
||||
if (value == "*") { cx.marked = "keyword"; return cont(maybeFrom, expect(";")); }
|
||||
if (value == "default") { cx.marked = "keyword"; return cont(expression, expect(";")); }
|
||||
if (type == "{") return cont(commasep(exportField, "}"), maybeFrom, expect(";"));
|
||||
return pass(statement);
|
||||
}
|
||||
function exportField(type, value) {
|
||||
if (value == "as") { cx.marked = "keyword"; return cont(expect("variable")); }
|
||||
if (type == "variable") return pass(expressionNoComma, exportField);
|
||||
}
|
||||
function afterImport(type) {
|
||||
if (type == "string") return cont();
|
||||
if (type == "(") return pass(expression);
|
||||
if (type == ".") return pass(maybeoperatorComma);
|
||||
return pass(importSpec, maybeMoreImports, maybeFrom);
|
||||
}
|
||||
function importSpec(type, value) {
|
||||
if (type == "{") return contCommasep(importSpec, "}");
|
||||
if (type == "variable") register(value);
|
||||
if (value == "*") cx.marked = "keyword";
|
||||
return cont(maybeAs);
|
||||
}
|
||||
function maybeMoreImports(type) {
|
||||
if (type == ",") return cont(importSpec, maybeMoreImports)
|
||||
}
|
||||
function maybeAs(_type, value) {
|
||||
if (value == "as") { cx.marked = "keyword"; return cont(importSpec); }
|
||||
}
|
||||
function maybeFrom(_type, value) {
|
||||
if (value == "from") { cx.marked = "keyword"; return cont(expression); }
|
||||
}
|
||||
function arrayLiteral(type) {
|
||||
if (type == "]") return cont();
|
||||
return pass(commasep(expressionNoComma, "]"));
|
||||
}
|
||||
function enumdef() {
|
||||
return pass(pushlex("form"), pattern, expect("{"), pushlex("}"), commasep(enummember, "}"), poplex, poplex)
|
||||
}
|
||||
function enummember() {
|
||||
return pass(pattern, maybeAssign);
|
||||
}
|
||||
|
||||
function isContinuedStatement(state, textAfter) {
|
||||
return state.lastType == "operator" || state.lastType == "," ||
|
||||
isOperatorChar.test(textAfter.charAt(0)) ||
|
||||
/[,.]/.test(textAfter.charAt(0));
|
||||
}
|
||||
|
||||
function expressionAllowed(stream, state, backUp) {
|
||||
return state.tokenize == tokenBase &&
|
||||
/^(?:operator|sof|keyword [bcd]|case|new|export|default|spread|[\[{}\(,;:]|=>)$/.test(state.lastType) ||
|
||||
(state.lastType == "quasi" && /\{\s*$/.test(stream.string.slice(0, stream.pos - (backUp || 0))))
|
||||
}
|
||||
|
||||
// Interface
|
||||
|
||||
return {
|
||||
startState: function(basecolumn) {
|
||||
var state = {
|
||||
tokenize: tokenBase,
|
||||
lastType: "sof",
|
||||
cc: [],
|
||||
lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false),
|
||||
localVars: parserConfig.localVars,
|
||||
context: parserConfig.localVars && new Context(null, null, false),
|
||||
indented: basecolumn || 0
|
||||
};
|
||||
if (parserConfig.globalVars && typeof parserConfig.globalVars == "object")
|
||||
state.globalVars = parserConfig.globalVars;
|
||||
return state;
|
||||
},
|
||||
|
||||
token: function(stream, state) {
|
||||
if (stream.sol()) {
|
||||
if (!state.lexical.hasOwnProperty("align"))
|
||||
state.lexical.align = false;
|
||||
state.indented = stream.indentation();
|
||||
findFatArrow(stream, state);
|
||||
}
|
||||
if (state.tokenize != tokenComment && stream.eatSpace()) return null;
|
||||
var style = state.tokenize(stream, state);
|
||||
if (type == "comment") return style;
|
||||
state.lastType = type == "operator" && (content == "++" || content == "--") ? "incdec" : type;
|
||||
return parseJS(state, style, type, content, stream);
|
||||
},
|
||||
|
||||
indent: function(state, textAfter) {
|
||||
if (state.tokenize == tokenComment || state.tokenize == tokenQuasi) return CodeMirror.Pass;
|
||||
if (state.tokenize != tokenBase) return 0;
|
||||
var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical, top;
|
||||
// Kludge to prevent 'maybelse' from blocking lexical scope pops
|
||||
if (!/^\s*else\b/.test(textAfter)) for (var i = state.cc.length - 1; i >= 0; --i) {
|
||||
var c = state.cc[i];
|
||||
if (c == poplex) lexical = lexical.prev;
|
||||
else if (c != maybeelse && c != popcontext) break;
|
||||
}
|
||||
while ((lexical.type == "stat" || lexical.type == "form") &&
|
||||
(firstChar == "}" || ((top = state.cc[state.cc.length - 1]) &&
|
||||
(top == maybeoperatorComma || top == maybeoperatorNoComma) &&
|
||||
!/^[,\.=+\-*:?[\(]/.test(textAfter))))
|
||||
lexical = lexical.prev;
|
||||
if (statementIndent && lexical.type == ")" && lexical.prev.type == "stat")
|
||||
lexical = lexical.prev;
|
||||
var type = lexical.type, closing = firstChar == type;
|
||||
|
||||
if (type == "vardef") return lexical.indented + (state.lastType == "operator" || state.lastType == "," ? lexical.info.length + 1 : 0);
|
||||
else if (type == "form" && firstChar == "{") return lexical.indented;
|
||||
else if (type == "form") return lexical.indented + indentUnit;
|
||||
else if (type == "stat")
|
||||
return lexical.indented + (isContinuedStatement(state, textAfter) ? statementIndent || indentUnit : 0);
|
||||
else if (lexical.info == "switch" && !closing && parserConfig.doubleIndentSwitch != false)
|
||||
return lexical.indented + (/^(?:case|default)\b/.test(textAfter) ? indentUnit : 2 * indentUnit);
|
||||
else if (lexical.align) return lexical.column + (closing ? 0 : 1);
|
||||
else return lexical.indented + (closing ? 0 : indentUnit);
|
||||
},
|
||||
|
||||
electricInput: /^\s*(?:case .*?:|default:|\{|\})$/,
|
||||
blockCommentStart: jsonMode ? null : "/*",
|
||||
blockCommentEnd: jsonMode ? null : "*/",
|
||||
blockCommentContinue: jsonMode ? null : " * ",
|
||||
lineComment: jsonMode ? null : "//",
|
||||
fold: "brace",
|
||||
closeBrackets: "()[]{}''\"\"``",
|
||||
|
||||
helperType: jsonMode ? "json" : "javascript",
|
||||
jsonldMode: jsonldMode,
|
||||
jsonMode: jsonMode,
|
||||
|
||||
expressionAllowed: expressionAllowed,
|
||||
|
||||
skipExpression: function(state) {
|
||||
parseJS(state, "atom", "atom", "true", new CodeMirror.StringStream("", 2, null));
|
||||
}
|
||||
};
|
||||
});
|
||||
|
||||
CodeMirror.registerHelper("wordChars", "javascript", /[\w$]/);
|
||||
|
||||
CodeMirror.defineMIME("text/javascript", "javascript");
|
||||
CodeMirror.defineMIME("text/ecmascript", "javascript");
|
||||
CodeMirror.defineMIME("application/javascript", "javascript");
|
||||
CodeMirror.defineMIME("application/x-javascript", "javascript");
|
||||
CodeMirror.defineMIME("application/ecmascript", "javascript");
|
||||
CodeMirror.defineMIME("application/json", { name: "javascript", json: true });
|
||||
CodeMirror.defineMIME("application/x-json", { name: "javascript", json: true });
|
||||
CodeMirror.defineMIME("application/manifest+json", { name: "javascript", json: true });
|
||||
CodeMirror.defineMIME("application/ld+json", { name: "javascript", jsonld: true });
|
||||
CodeMirror.defineMIME("text/typescript", { name: "javascript", typescript: true });
|
||||
CodeMirror.defineMIME("application/typescript", { name: "javascript", typescript: true });
|
||||
|
||||
});
|
||||
});
|
||||
|
||||
export default javascript;
|
||||
115
docs/_snowpack/pkg/codemirror/mode/pegjs/pegjs.js
vendored
115
docs/_snowpack/pkg/codemirror/mode/pegjs/pegjs.js
vendored
@ -1,115 +0,0 @@
|
||||
import { c as createCommonjsModule } from '../../../common/_commonjsHelpers-8c19dec8.js';
|
||||
import { c as codemirror } from '../../../common/codemirror-d650d44d.js';
|
||||
import javascript from '../javascript/javascript.js';
|
||||
|
||||
var pegjs = createCommonjsModule(function (module, exports) {
|
||||
// CodeMirror, copyright (c) by Marijn Haverbeke and others
|
||||
// Distributed under an MIT license: https://codemirror.net/LICENSE
|
||||
|
||||
(function(mod) {
|
||||
mod(codemirror, javascript);
|
||||
})(function(CodeMirror) {
|
||||
|
||||
CodeMirror.defineMode("pegjs", function (config) {
|
||||
var jsMode = CodeMirror.getMode(config, "javascript");
|
||||
|
||||
function identifier(stream) {
|
||||
return stream.match(/^[a-zA-Z_][a-zA-Z0-9_]*/);
|
||||
}
|
||||
|
||||
return {
|
||||
startState: function () {
|
||||
return {
|
||||
inString: false,
|
||||
stringType: null,
|
||||
inComment: false,
|
||||
inCharacterClass: false,
|
||||
braced: 0,
|
||||
lhs: true,
|
||||
localState: null
|
||||
};
|
||||
},
|
||||
token: function (stream, state) {
|
||||
if (stream)
|
||||
|
||||
//check for state changes
|
||||
if (!state.inString && !state.inComment && ((stream.peek() == '"') || (stream.peek() == "'"))) {
|
||||
state.stringType = stream.peek();
|
||||
stream.next(); // Skip quote
|
||||
state.inString = true; // Update state
|
||||
}
|
||||
if (!state.inString && !state.inComment && stream.match('/*')) {
|
||||
state.inComment = true;
|
||||
}
|
||||
|
||||
//return state
|
||||
if (state.inString) {
|
||||
while (state.inString && !stream.eol()) {
|
||||
if (stream.peek() === state.stringType) {
|
||||
stream.next(); // Skip quote
|
||||
state.inString = false; // Clear flag
|
||||
} else if (stream.peek() === '\\') {
|
||||
stream.next();
|
||||
stream.next();
|
||||
} else {
|
||||
stream.match(/^.[^\\\"\']*/);
|
||||
}
|
||||
}
|
||||
return state.lhs ? "property string" : "string"; // Token style
|
||||
} else if (state.inComment) {
|
||||
while (state.inComment && !stream.eol()) {
|
||||
if (stream.match('*/')) {
|
||||
state.inComment = false; // Clear flag
|
||||
} else {
|
||||
stream.match(/^.[^\*]*/);
|
||||
}
|
||||
}
|
||||
return "comment";
|
||||
} else if (state.inCharacterClass) {
|
||||
while (state.inCharacterClass && !stream.eol()) {
|
||||
if (!(stream.match(/^[^\]\\]+/) || stream.match(/^\\./))) {
|
||||
state.inCharacterClass = false;
|
||||
}
|
||||
}
|
||||
} else if (stream.peek() === '[') {
|
||||
stream.next();
|
||||
state.inCharacterClass = true;
|
||||
return 'bracket';
|
||||
} else if (stream.match('//')) {
|
||||
stream.skipToEnd();
|
||||
return "comment";
|
||||
} else if (state.braced || stream.peek() === '{') {
|
||||
if (state.localState === null) {
|
||||
state.localState = CodeMirror.startState(jsMode);
|
||||
}
|
||||
var token = jsMode.token(stream, state.localState);
|
||||
var text = stream.current();
|
||||
if (!token) {
|
||||
for (var i = 0; i < text.length; i++) {
|
||||
if (text[i] === '{') {
|
||||
state.braced++;
|
||||
} else if (text[i] === '}') {
|
||||
state.braced--;
|
||||
}
|
||||
} }
|
||||
return token;
|
||||
} else if (identifier(stream)) {
|
||||
if (stream.peek() === ':') {
|
||||
return 'variable';
|
||||
}
|
||||
return 'variable-2';
|
||||
} else if (['[', ']', '(', ')'].indexOf(stream.peek()) != -1) {
|
||||
stream.next();
|
||||
return 'bracket';
|
||||
} else if (!stream.eatSpace()) {
|
||||
stream.next();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
};
|
||||
}, "javascript");
|
||||
|
||||
});
|
||||
});
|
||||
|
||||
export default pegjs;
|
||||
141
docs/_snowpack/pkg/codemirror/theme/material.css
vendored
141
docs/_snowpack/pkg/codemirror/theme/material.css
vendored
@ -1,141 +0,0 @@
|
||||
/*
|
||||
Name: material
|
||||
Author: Mattia Astorino (http://github.com/equinusocio)
|
||||
Website: https://material-theme.site/
|
||||
*/
|
||||
|
||||
.cm-s-material.CodeMirror {
|
||||
background-color: #263238;
|
||||
color: #EEFFFF;
|
||||
}
|
||||
|
||||
.cm-s-material .CodeMirror-gutters {
|
||||
background: #263238;
|
||||
color: #546E7A;
|
||||
border: none;
|
||||
}
|
||||
|
||||
.cm-s-material .CodeMirror-guttermarker,
|
||||
.cm-s-material .CodeMirror-guttermarker-subtle,
|
||||
.cm-s-material .CodeMirror-linenumber {
|
||||
color: #546E7A;
|
||||
}
|
||||
|
||||
.cm-s-material .CodeMirror-cursor {
|
||||
border-left: 1px solid #FFCC00;
|
||||
}
|
||||
.cm-s-material.cm-fat-cursor .CodeMirror-cursor {
|
||||
background-color: #5d6d5c80 !important;
|
||||
}
|
||||
.cm-s-material .cm-animate-fat-cursor {
|
||||
background-color: #5d6d5c80 !important;
|
||||
}
|
||||
|
||||
.cm-s-material div.CodeMirror-selected {
|
||||
background: rgba(128, 203, 196, 0.2);
|
||||
}
|
||||
|
||||
.cm-s-material.CodeMirror-focused div.CodeMirror-selected {
|
||||
background: rgba(128, 203, 196, 0.2);
|
||||
}
|
||||
|
||||
.cm-s-material .CodeMirror-line::selection,
|
||||
.cm-s-material .CodeMirror-line>span::selection,
|
||||
.cm-s-material .CodeMirror-line>span>span::selection {
|
||||
background: rgba(128, 203, 196, 0.2);
|
||||
}
|
||||
|
||||
.cm-s-material .CodeMirror-line::-moz-selection,
|
||||
.cm-s-material .CodeMirror-line>span::-moz-selection,
|
||||
.cm-s-material .CodeMirror-line>span>span::-moz-selection {
|
||||
background: rgba(128, 203, 196, 0.2);
|
||||
}
|
||||
|
||||
.cm-s-material .CodeMirror-activeline-background {
|
||||
background: rgba(0, 0, 0, 0.5);
|
||||
}
|
||||
|
||||
.cm-s-material .cm-keyword {
|
||||
color: #C792EA;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-operator {
|
||||
color: #89DDFF;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-variable-2 {
|
||||
color: #EEFFFF;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-variable-3,
|
||||
.cm-s-material .cm-type {
|
||||
color: #f07178;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-builtin {
|
||||
color: #FFCB6B;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-atom {
|
||||
color: #F78C6C;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-number {
|
||||
color: #FF5370;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-def {
|
||||
color: #82AAFF;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-string {
|
||||
color: #C3E88D;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-string-2 {
|
||||
color: #f07178;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-comment {
|
||||
color: #546E7A;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-variable {
|
||||
color: #f07178;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-tag {
|
||||
color: #FF5370;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-meta {
|
||||
color: #FFCB6B;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-attribute {
|
||||
color: #C792EA;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-property {
|
||||
color: #C792EA;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-qualifier {
|
||||
color: #DECB6B;
|
||||
}
|
||||
|
||||
.cm-s-material .cm-variable-3,
|
||||
.cm-s-material .cm-type {
|
||||
color: #DECB6B;
|
||||
}
|
||||
|
||||
|
||||
.cm-s-material .cm-error {
|
||||
color: rgba(255, 255, 255, 1.0);
|
||||
background-color: #FF5370;
|
||||
}
|
||||
|
||||
.cm-s-material .CodeMirror-matchingbracket {
|
||||
text-decoration: underline;
|
||||
color: white !important;
|
||||
}
|
||||
@ -1,10 +0,0 @@
|
||||
// [snowpack] add styles to the page (skip if no document exists)
|
||||
if (typeof document !== 'undefined') {
|
||||
const code = "/*\n Name: material\n Author: Mattia Astorino (http://github.com/equinusocio)\n Website: https://material-theme.site/\n*/\n\n.cm-s-material.CodeMirror {\n background-color: #263238;\n color: #EEFFFF;\n}\n\n.cm-s-material .CodeMirror-gutters {\n background: #263238;\n color: #546E7A;\n border: none;\n}\n\n.cm-s-material .CodeMirror-guttermarker,\n.cm-s-material .CodeMirror-guttermarker-subtle,\n.cm-s-material .CodeMirror-linenumber {\n color: #546E7A;\n}\n\n.cm-s-material .CodeMirror-cursor {\n border-left: 1px solid #FFCC00;\n}\n.cm-s-material.cm-fat-cursor .CodeMirror-cursor {\n background-color: #5d6d5c80 !important;\n}\n.cm-s-material .cm-animate-fat-cursor {\n background-color: #5d6d5c80 !important;\n}\n\n.cm-s-material div.CodeMirror-selected {\n background: rgba(128, 203, 196, 0.2);\n}\n\n.cm-s-material.CodeMirror-focused div.CodeMirror-selected {\n background: rgba(128, 203, 196, 0.2);\n}\n\n.cm-s-material .CodeMirror-line::selection,\n.cm-s-material .CodeMirror-line>span::selection,\n.cm-s-material .CodeMirror-line>span>span::selection {\n background: rgba(128, 203, 196, 0.2);\n}\n\n.cm-s-material .CodeMirror-line::-moz-selection,\n.cm-s-material .CodeMirror-line>span::-moz-selection,\n.cm-s-material .CodeMirror-line>span>span::-moz-selection {\n background: rgba(128, 203, 196, 0.2);\n}\n\n.cm-s-material .CodeMirror-activeline-background {\n background: rgba(0, 0, 0, 0.5);\n}\n\n.cm-s-material .cm-keyword {\n color: #C792EA;\n}\n\n.cm-s-material .cm-operator {\n color: #89DDFF;\n}\n\n.cm-s-material .cm-variable-2 {\n color: #EEFFFF;\n}\n\n.cm-s-material .cm-variable-3,\n.cm-s-material .cm-type {\n color: #f07178;\n}\n\n.cm-s-material .cm-builtin {\n color: #FFCB6B;\n}\n\n.cm-s-material .cm-atom {\n color: #F78C6C;\n}\n\n.cm-s-material .cm-number {\n color: #FF5370;\n}\n\n.cm-s-material .cm-def {\n color: #82AAFF;\n}\n\n.cm-s-material .cm-string {\n color: #C3E88D;\n}\n\n.cm-s-material .cm-string-2 {\n color: #f07178;\n}\n\n.cm-s-material .cm-comment {\n color: #546E7A;\n}\n\n.cm-s-material .cm-variable {\n color: #f07178;\n}\n\n.cm-s-material .cm-tag {\n color: #FF5370;\n}\n\n.cm-s-material .cm-meta {\n color: #FFCB6B;\n}\n\n.cm-s-material .cm-attribute {\n color: #C792EA;\n}\n\n.cm-s-material .cm-property {\n color: #C792EA;\n}\n\n.cm-s-material .cm-qualifier {\n color: #DECB6B;\n}\n\n.cm-s-material .cm-variable-3,\n.cm-s-material .cm-type {\n color: #DECB6B;\n}\n\n\n.cm-s-material .cm-error {\n color: rgba(255, 255, 255, 1.0);\n background-color: #FF5370;\n}\n\n.cm-s-material .CodeMirror-matchingbracket {\n text-decoration: underline;\n color: white !important;\n}\n";
|
||||
|
||||
const styleEl = document.createElement("style");
|
||||
const codeEl = document.createTextNode(code);
|
||||
styleEl.type = 'text/css';
|
||||
styleEl.appendChild(codeEl);
|
||||
document.head.appendChild(styleEl);
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
|
||||
|
||||
function getDefaultExportFromCjs (x) {
|
||||
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
|
||||
}
|
||||
|
||||
function createCommonjsModule(fn, basedir, module) {
|
||||
return module = {
|
||||
path: basedir,
|
||||
exports: {},
|
||||
require: function (path, base) {
|
||||
return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
|
||||
}
|
||||
}, fn(module, module.exports), module.exports;
|
||||
}
|
||||
|
||||
function commonjsRequire () {
|
||||
throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
|
||||
}
|
||||
|
||||
export { commonjsGlobal as a, createCommonjsModule as c, getDefaultExportFromCjs as g };
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,29 +0,0 @@
|
||||
import { c as createCommonjsModule } from './_commonjsHelpers-8c19dec8.js';
|
||||
import { o as objectAssign } from './index-d01087d6.js';
|
||||
|
||||
var react_production_min = createCommonjsModule(function (module, exports) {
|
||||
var n=60103,p=60106;exports.Fragment=60107;exports.StrictMode=60108;exports.Profiler=60114;var q=60109,r=60110,t=60112;exports.Suspense=60113;var u=60115,v=60116;
|
||||
if("function"===typeof Symbol&&Symbol.for){var w=Symbol.for;n=w("react.element");p=w("react.portal");exports.Fragment=w("react.fragment");exports.StrictMode=w("react.strict_mode");exports.Profiler=w("react.profiler");q=w("react.provider");r=w("react.context");t=w("react.forward_ref");exports.Suspense=w("react.suspense");u=w("react.memo");v=w("react.lazy");}var x="function"===typeof Symbol&&Symbol.iterator;
|
||||
function y(a){if(null===a||"object"!==typeof a)return null;a=x&&a[x]||a["@@iterator"];return "function"===typeof a?a:null}function z(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return "Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}
|
||||
var A={isMounted:function(){return !1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},B={};function C(a,b,c){this.props=a;this.context=b;this.refs=B;this.updater=c||A;}C.prototype.isReactComponent={};C.prototype.setState=function(a,b){if("object"!==typeof a&&"function"!==typeof a&&null!=a)throw Error(z(85));this.updater.enqueueSetState(this,a,b,"setState");};C.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,"forceUpdate");};
|
||||
function D(){}D.prototype=C.prototype;function E(a,b,c){this.props=a;this.context=b;this.refs=B;this.updater=c||A;}var F=E.prototype=new D;F.constructor=E;objectAssign(F,C.prototype);F.isPureReactComponent=!0;var G={current:null},H=Object.prototype.hasOwnProperty,I={key:!0,ref:!0,__self:!0,__source:!0};
|
||||
function J(a,b,c){var e,d={},k=null,h=null;if(null!=b)for(e in void 0!==b.ref&&(h=b.ref),void 0!==b.key&&(k=""+b.key),b)H.call(b,e)&&!I.hasOwnProperty(e)&&(d[e]=b[e]);var g=arguments.length-2;if(1===g)d.children=c;else if(1<g){for(var f=Array(g),m=0;m<g;m++)f[m]=arguments[m+2];d.children=f;}if(a&&a.defaultProps)for(e in g=a.defaultProps,g)void 0===d[e]&&(d[e]=g[e]);return {$$typeof:n,type:a,key:k,ref:h,props:d,_owner:G.current}}
|
||||
function K(a,b){return {$$typeof:n,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}}function L(a){return "object"===typeof a&&null!==a&&a.$$typeof===n}function escape(a){var b={"=":"=0",":":"=2"};return "$"+a.replace(/[=:]/g,function(a){return b[a]})}var M=/\/+/g;function N(a,b){return "object"===typeof a&&null!==a&&null!=a.key?escape(""+a.key):b.toString(36)}
|
||||
function O(a,b,c,e,d){var k=typeof a;if("undefined"===k||"boolean"===k)a=null;var h=!1;if(null===a)h=!0;else switch(k){case "string":case "number":h=!0;break;case "object":switch(a.$$typeof){case n:case p:h=!0;}}if(h)return h=a,d=d(h),a=""===e?"."+N(h,0):e,Array.isArray(d)?(c="",null!=a&&(c=a.replace(M,"$&/")+"/"),O(d,b,c,"",function(a){return a})):null!=d&&(L(d)&&(d=K(d,c+(!d.key||h&&h.key===d.key?"":(""+d.key).replace(M,"$&/")+"/")+a)),b.push(d)),1;h=0;e=""===e?".":e+":";if(Array.isArray(a))for(var g=
|
||||
0;g<a.length;g++){k=a[g];var f=e+N(k,g);h+=O(k,b,c,f,d);}else if(f=y(a),"function"===typeof f)for(a=f.call(a),g=0;!(k=a.next()).done;)k=k.value,f=e+N(k,g++),h+=O(k,b,c,f,d);else if("object"===k)throw b=""+a,Error(z(31,"[object Object]"===b?"object with keys {"+Object.keys(a).join(", ")+"}":b));return h}function P(a,b,c){if(null==a)return a;var e=[],d=0;O(a,e,"","",function(a){return b.call(c,a,d++)});return e}
|
||||
function Q(a){if(-1===a._status){var b=a._result;b=b();a._status=0;a._result=b;b.then(function(b){0===a._status&&(b=b.default,a._status=1,a._result=b);},function(b){0===a._status&&(a._status=2,a._result=b);});}if(1===a._status)return a._result;throw a._result;}var R={current:null};function S(){var a=R.current;if(null===a)throw Error(z(321));return a}var T={ReactCurrentDispatcher:R,ReactCurrentBatchConfig:{transition:0},ReactCurrentOwner:G,IsSomeRendererActing:{current:!1},assign:objectAssign};
|
||||
exports.Children={map:P,forEach:function(a,b,c){P(a,function(){b.apply(this,arguments);},c);},count:function(a){var b=0;P(a,function(){b++;});return b},toArray:function(a){return P(a,function(a){return a})||[]},only:function(a){if(!L(a))throw Error(z(143));return a}};exports.Component=C;exports.PureComponent=E;exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=T;
|
||||
exports.cloneElement=function(a,b,c){if(null===a||void 0===a)throw Error(z(267,a));var e=objectAssign({},a.props),d=a.key,k=a.ref,h=a._owner;if(null!=b){void 0!==b.ref&&(k=b.ref,h=G.current);void 0!==b.key&&(d=""+b.key);if(a.type&&a.type.defaultProps)var g=a.type.defaultProps;for(f in b)H.call(b,f)&&!I.hasOwnProperty(f)&&(e[f]=void 0===b[f]&&void 0!==g?g[f]:b[f]);}var f=arguments.length-2;if(1===f)e.children=c;else if(1<f){g=Array(f);for(var m=0;m<f;m++)g[m]=arguments[m+2];e.children=g;}return {$$typeof:n,type:a.type,
|
||||
key:d,ref:k,props:e,_owner:h}};exports.createContext=function(a,b){void 0===b&&(b=null);a={$$typeof:r,_calculateChangedBits:b,_currentValue:a,_currentValue2:a,_threadCount:0,Provider:null,Consumer:null};a.Provider={$$typeof:q,_context:a};return a.Consumer=a};exports.createElement=J;exports.createFactory=function(a){var b=J.bind(null,a);b.type=a;return b};exports.createRef=function(){return {current:null}};exports.forwardRef=function(a){return {$$typeof:t,render:a}};exports.isValidElement=L;
|
||||
exports.lazy=function(a){return {$$typeof:v,_payload:{_status:-1,_result:a},_init:Q}};exports.memo=function(a,b){return {$$typeof:u,type:a,compare:void 0===b?null:b}};exports.useCallback=function(a,b){return S().useCallback(a,b)};exports.useContext=function(a,b){return S().useContext(a,b)};exports.useDebugValue=function(){};exports.useEffect=function(a,b){return S().useEffect(a,b)};exports.useImperativeHandle=function(a,b,c){return S().useImperativeHandle(a,b,c)};
|
||||
exports.useLayoutEffect=function(a,b){return S().useLayoutEffect(a,b)};exports.useMemo=function(a,b){return S().useMemo(a,b)};exports.useReducer=function(a,b,c){return S().useReducer(a,b,c)};exports.useRef=function(a){return S().useRef(a)};exports.useState=function(a){return S().useState(a)};exports.version="17.0.2";
|
||||
});
|
||||
|
||||
var react = createCommonjsModule(function (module) {
|
||||
|
||||
{
|
||||
module.exports = react_production_min;
|
||||
}
|
||||
});
|
||||
|
||||
export { react as r };
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,90 +0,0 @@
|
||||
/*
|
||||
object-assign
|
||||
(c) Sindre Sorhus
|
||||
@license MIT
|
||||
*/
|
||||
/* eslint-disable no-unused-vars */
|
||||
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
|
||||
|
||||
function toObject(val) {
|
||||
if (val === null || val === undefined) {
|
||||
throw new TypeError('Object.assign cannot be called with null or undefined');
|
||||
}
|
||||
|
||||
return Object(val);
|
||||
}
|
||||
|
||||
function shouldUseNative() {
|
||||
try {
|
||||
if (!Object.assign) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Detect buggy property enumeration order in older V8 versions.
|
||||
|
||||
// https://bugs.chromium.org/p/v8/issues/detail?id=4118
|
||||
var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
|
||||
test1[5] = 'de';
|
||||
if (Object.getOwnPropertyNames(test1)[0] === '5') {
|
||||
return false;
|
||||
}
|
||||
|
||||
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
|
||||
var test2 = {};
|
||||
for (var i = 0; i < 10; i++) {
|
||||
test2['_' + String.fromCharCode(i)] = i;
|
||||
}
|
||||
var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
|
||||
return test2[n];
|
||||
});
|
||||
if (order2.join('') !== '0123456789') {
|
||||
return false;
|
||||
}
|
||||
|
||||
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
|
||||
var test3 = {};
|
||||
'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
|
||||
test3[letter] = letter;
|
||||
});
|
||||
if (Object.keys(Object.assign({}, test3)).join('') !==
|
||||
'abcdefghijklmnopqrst') {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
} catch (err) {
|
||||
// We don't expect any of the above to throw, but better to be safe.
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
|
||||
var from;
|
||||
var to = toObject(target);
|
||||
var symbols;
|
||||
|
||||
for (var s = 1; s < arguments.length; s++) {
|
||||
from = Object(arguments[s]);
|
||||
|
||||
for (var key in from) {
|
||||
if (hasOwnProperty.call(from, key)) {
|
||||
to[key] = from[key];
|
||||
}
|
||||
}
|
||||
|
||||
if (getOwnPropertySymbols) {
|
||||
symbols = getOwnPropertySymbols(from);
|
||||
for (var i = 0; i < symbols.length; i++) {
|
||||
if (propIsEnumerable.call(from, symbols[i])) {
|
||||
to[symbols[i]] = from[symbols[i]];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return to;
|
||||
};
|
||||
|
||||
export { objectAssign as o };
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
@ -1,810 +0,0 @@
|
||||
import { c as createCommonjsModule } from './common/_commonjsHelpers-8c19dec8.js';
|
||||
|
||||
var estraverse = createCommonjsModule(function (module, exports) {
|
||||
/*
|
||||
Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
|
||||
Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
/*jslint vars:false, bitwise:true*/
|
||||
/*jshint indent:4*/
|
||||
/*global exports:true*/
|
||||
(function clone(exports) {
|
||||
|
||||
var Syntax,
|
||||
VisitorOption,
|
||||
VisitorKeys,
|
||||
BREAK,
|
||||
SKIP,
|
||||
REMOVE;
|
||||
|
||||
function deepCopy(obj) {
|
||||
var ret = {}, key, val;
|
||||
for (key in obj) {
|
||||
if (obj.hasOwnProperty(key)) {
|
||||
val = obj[key];
|
||||
if (typeof val === 'object' && val !== null) {
|
||||
ret[key] = deepCopy(val);
|
||||
} else {
|
||||
ret[key] = val;
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
// based on LLVM libc++ upper_bound / lower_bound
|
||||
// MIT License
|
||||
|
||||
function upperBound(array, func) {
|
||||
var diff, len, i, current;
|
||||
|
||||
len = array.length;
|
||||
i = 0;
|
||||
|
||||
while (len) {
|
||||
diff = len >>> 1;
|
||||
current = i + diff;
|
||||
if (func(array[current])) {
|
||||
len = diff;
|
||||
} else {
|
||||
i = current + 1;
|
||||
len -= diff + 1;
|
||||
}
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
Syntax = {
|
||||
AssignmentExpression: 'AssignmentExpression',
|
||||
AssignmentPattern: 'AssignmentPattern',
|
||||
ArrayExpression: 'ArrayExpression',
|
||||
ArrayPattern: 'ArrayPattern',
|
||||
ArrowFunctionExpression: 'ArrowFunctionExpression',
|
||||
AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7.
|
||||
BlockStatement: 'BlockStatement',
|
||||
BinaryExpression: 'BinaryExpression',
|
||||
BreakStatement: 'BreakStatement',
|
||||
CallExpression: 'CallExpression',
|
||||
CatchClause: 'CatchClause',
|
||||
ChainExpression: 'ChainExpression',
|
||||
ClassBody: 'ClassBody',
|
||||
ClassDeclaration: 'ClassDeclaration',
|
||||
ClassExpression: 'ClassExpression',
|
||||
ComprehensionBlock: 'ComprehensionBlock', // CAUTION: It's deferred to ES7.
|
||||
ComprehensionExpression: 'ComprehensionExpression', // CAUTION: It's deferred to ES7.
|
||||
ConditionalExpression: 'ConditionalExpression',
|
||||
ContinueStatement: 'ContinueStatement',
|
||||
DebuggerStatement: 'DebuggerStatement',
|
||||
DirectiveStatement: 'DirectiveStatement',
|
||||
DoWhileStatement: 'DoWhileStatement',
|
||||
EmptyStatement: 'EmptyStatement',
|
||||
ExportAllDeclaration: 'ExportAllDeclaration',
|
||||
ExportDefaultDeclaration: 'ExportDefaultDeclaration',
|
||||
ExportNamedDeclaration: 'ExportNamedDeclaration',
|
||||
ExportSpecifier: 'ExportSpecifier',
|
||||
ExpressionStatement: 'ExpressionStatement',
|
||||
ForStatement: 'ForStatement',
|
||||
ForInStatement: 'ForInStatement',
|
||||
ForOfStatement: 'ForOfStatement',
|
||||
FunctionDeclaration: 'FunctionDeclaration',
|
||||
FunctionExpression: 'FunctionExpression',
|
||||
GeneratorExpression: 'GeneratorExpression', // CAUTION: It's deferred to ES7.
|
||||
Identifier: 'Identifier',
|
||||
IfStatement: 'IfStatement',
|
||||
ImportExpression: 'ImportExpression',
|
||||
ImportDeclaration: 'ImportDeclaration',
|
||||
ImportDefaultSpecifier: 'ImportDefaultSpecifier',
|
||||
ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
|
||||
ImportSpecifier: 'ImportSpecifier',
|
||||
Literal: 'Literal',
|
||||
LabeledStatement: 'LabeledStatement',
|
||||
LogicalExpression: 'LogicalExpression',
|
||||
MemberExpression: 'MemberExpression',
|
||||
MetaProperty: 'MetaProperty',
|
||||
MethodDefinition: 'MethodDefinition',
|
||||
ModuleSpecifier: 'ModuleSpecifier',
|
||||
NewExpression: 'NewExpression',
|
||||
ObjectExpression: 'ObjectExpression',
|
||||
ObjectPattern: 'ObjectPattern',
|
||||
PrivateIdentifier: 'PrivateIdentifier',
|
||||
Program: 'Program',
|
||||
Property: 'Property',
|
||||
PropertyDefinition: 'PropertyDefinition',
|
||||
RestElement: 'RestElement',
|
||||
ReturnStatement: 'ReturnStatement',
|
||||
SequenceExpression: 'SequenceExpression',
|
||||
SpreadElement: 'SpreadElement',
|
||||
Super: 'Super',
|
||||
SwitchStatement: 'SwitchStatement',
|
||||
SwitchCase: 'SwitchCase',
|
||||
TaggedTemplateExpression: 'TaggedTemplateExpression',
|
||||
TemplateElement: 'TemplateElement',
|
||||
TemplateLiteral: 'TemplateLiteral',
|
||||
ThisExpression: 'ThisExpression',
|
||||
ThrowStatement: 'ThrowStatement',
|
||||
TryStatement: 'TryStatement',
|
||||
UnaryExpression: 'UnaryExpression',
|
||||
UpdateExpression: 'UpdateExpression',
|
||||
VariableDeclaration: 'VariableDeclaration',
|
||||
VariableDeclarator: 'VariableDeclarator',
|
||||
WhileStatement: 'WhileStatement',
|
||||
WithStatement: 'WithStatement',
|
||||
YieldExpression: 'YieldExpression'
|
||||
};
|
||||
|
||||
VisitorKeys = {
|
||||
AssignmentExpression: ['left', 'right'],
|
||||
AssignmentPattern: ['left', 'right'],
|
||||
ArrayExpression: ['elements'],
|
||||
ArrayPattern: ['elements'],
|
||||
ArrowFunctionExpression: ['params', 'body'],
|
||||
AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7.
|
||||
BlockStatement: ['body'],
|
||||
BinaryExpression: ['left', 'right'],
|
||||
BreakStatement: ['label'],
|
||||
CallExpression: ['callee', 'arguments'],
|
||||
CatchClause: ['param', 'body'],
|
||||
ChainExpression: ['expression'],
|
||||
ClassBody: ['body'],
|
||||
ClassDeclaration: ['id', 'superClass', 'body'],
|
||||
ClassExpression: ['id', 'superClass', 'body'],
|
||||
ComprehensionBlock: ['left', 'right'], // CAUTION: It's deferred to ES7.
|
||||
ComprehensionExpression: ['blocks', 'filter', 'body'], // CAUTION: It's deferred to ES7.
|
||||
ConditionalExpression: ['test', 'consequent', 'alternate'],
|
||||
ContinueStatement: ['label'],
|
||||
DebuggerStatement: [],
|
||||
DirectiveStatement: [],
|
||||
DoWhileStatement: ['body', 'test'],
|
||||
EmptyStatement: [],
|
||||
ExportAllDeclaration: ['source'],
|
||||
ExportDefaultDeclaration: ['declaration'],
|
||||
ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
|
||||
ExportSpecifier: ['exported', 'local'],
|
||||
ExpressionStatement: ['expression'],
|
||||
ForStatement: ['init', 'test', 'update', 'body'],
|
||||
ForInStatement: ['left', 'right', 'body'],
|
||||
ForOfStatement: ['left', 'right', 'body'],
|
||||
FunctionDeclaration: ['id', 'params', 'body'],
|
||||
FunctionExpression: ['id', 'params', 'body'],
|
||||
GeneratorExpression: ['blocks', 'filter', 'body'], // CAUTION: It's deferred to ES7.
|
||||
Identifier: [],
|
||||
IfStatement: ['test', 'consequent', 'alternate'],
|
||||
ImportExpression: ['source'],
|
||||
ImportDeclaration: ['specifiers', 'source'],
|
||||
ImportDefaultSpecifier: ['local'],
|
||||
ImportNamespaceSpecifier: ['local'],
|
||||
ImportSpecifier: ['imported', 'local'],
|
||||
Literal: [],
|
||||
LabeledStatement: ['label', 'body'],
|
||||
LogicalExpression: ['left', 'right'],
|
||||
MemberExpression: ['object', 'property'],
|
||||
MetaProperty: ['meta', 'property'],
|
||||
MethodDefinition: ['key', 'value'],
|
||||
ModuleSpecifier: [],
|
||||
NewExpression: ['callee', 'arguments'],
|
||||
ObjectExpression: ['properties'],
|
||||
ObjectPattern: ['properties'],
|
||||
PrivateIdentifier: [],
|
||||
Program: ['body'],
|
||||
Property: ['key', 'value'],
|
||||
PropertyDefinition: ['key', 'value'],
|
||||
RestElement: [ 'argument' ],
|
||||
ReturnStatement: ['argument'],
|
||||
SequenceExpression: ['expressions'],
|
||||
SpreadElement: ['argument'],
|
||||
Super: [],
|
||||
SwitchStatement: ['discriminant', 'cases'],
|
||||
SwitchCase: ['test', 'consequent'],
|
||||
TaggedTemplateExpression: ['tag', 'quasi'],
|
||||
TemplateElement: [],
|
||||
TemplateLiteral: ['quasis', 'expressions'],
|
||||
ThisExpression: [],
|
||||
ThrowStatement: ['argument'],
|
||||
TryStatement: ['block', 'handler', 'finalizer'],
|
||||
UnaryExpression: ['argument'],
|
||||
UpdateExpression: ['argument'],
|
||||
VariableDeclaration: ['declarations'],
|
||||
VariableDeclarator: ['id', 'init'],
|
||||
WhileStatement: ['test', 'body'],
|
||||
WithStatement: ['object', 'body'],
|
||||
YieldExpression: ['argument']
|
||||
};
|
||||
|
||||
// unique id
|
||||
BREAK = {};
|
||||
SKIP = {};
|
||||
REMOVE = {};
|
||||
|
||||
VisitorOption = {
|
||||
Break: BREAK,
|
||||
Skip: SKIP,
|
||||
Remove: REMOVE
|
||||
};
|
||||
|
||||
function Reference(parent, key) {
|
||||
this.parent = parent;
|
||||
this.key = key;
|
||||
}
|
||||
|
||||
Reference.prototype.replace = function replace(node) {
|
||||
this.parent[this.key] = node;
|
||||
};
|
||||
|
||||
Reference.prototype.remove = function remove() {
|
||||
if (Array.isArray(this.parent)) {
|
||||
this.parent.splice(this.key, 1);
|
||||
return true;
|
||||
} else {
|
||||
this.replace(null);
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
function Element(node, path, wrap, ref) {
|
||||
this.node = node;
|
||||
this.path = path;
|
||||
this.wrap = wrap;
|
||||
this.ref = ref;
|
||||
}
|
||||
|
||||
function Controller() { }
|
||||
|
||||
// API:
|
||||
// return property path array from root to current node
|
||||
Controller.prototype.path = function path() {
|
||||
var i, iz, j, jz, result, element;
|
||||
|
||||
function addToPath(result, path) {
|
||||
if (Array.isArray(path)) {
|
||||
for (j = 0, jz = path.length; j < jz; ++j) {
|
||||
result.push(path[j]);
|
||||
}
|
||||
} else {
|
||||
result.push(path);
|
||||
}
|
||||
}
|
||||
|
||||
// root node
|
||||
if (!this.__current.path) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// first node is sentinel, second node is root element
|
||||
result = [];
|
||||
for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
|
||||
element = this.__leavelist[i];
|
||||
addToPath(result, element.path);
|
||||
}
|
||||
addToPath(result, this.__current.path);
|
||||
return result;
|
||||
};
|
||||
|
||||
// API:
|
||||
// return type of current node
|
||||
Controller.prototype.type = function () {
|
||||
var node = this.current();
|
||||
return node.type || this.__current.wrap;
|
||||
};
|
||||
|
||||
// API:
|
||||
// return array of parent elements
|
||||
Controller.prototype.parents = function parents() {
|
||||
var i, iz, result;
|
||||
|
||||
// first node is sentinel
|
||||
result = [];
|
||||
for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
|
||||
result.push(this.__leavelist[i].node);
|
||||
}
|
||||
|
||||
return result;
|
||||
};
|
||||
|
||||
// API:
|
||||
// return current node
|
||||
Controller.prototype.current = function current() {
|
||||
return this.__current.node;
|
||||
};
|
||||
|
||||
Controller.prototype.__execute = function __execute(callback, element) {
|
||||
var previous, result;
|
||||
|
||||
result = undefined;
|
||||
|
||||
previous = this.__current;
|
||||
this.__current = element;
|
||||
this.__state = null;
|
||||
if (callback) {
|
||||
result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
|
||||
}
|
||||
this.__current = previous;
|
||||
|
||||
return result;
|
||||
};
|
||||
|
||||
// API:
|
||||
// notify control skip / break
|
||||
Controller.prototype.notify = function notify(flag) {
|
||||
this.__state = flag;
|
||||
};
|
||||
|
||||
// API:
|
||||
// skip child nodes of current node
|
||||
Controller.prototype.skip = function () {
|
||||
this.notify(SKIP);
|
||||
};
|
||||
|
||||
// API:
|
||||
// break traversals
|
||||
Controller.prototype['break'] = function () {
|
||||
this.notify(BREAK);
|
||||
};
|
||||
|
||||
// API:
|
||||
// remove node
|
||||
Controller.prototype.remove = function () {
|
||||
this.notify(REMOVE);
|
||||
};
|
||||
|
||||
Controller.prototype.__initialize = function(root, visitor) {
|
||||
this.visitor = visitor;
|
||||
this.root = root;
|
||||
this.__worklist = [];
|
||||
this.__leavelist = [];
|
||||
this.__current = null;
|
||||
this.__state = null;
|
||||
this.__fallback = null;
|
||||
if (visitor.fallback === 'iteration') {
|
||||
this.__fallback = Object.keys;
|
||||
} else if (typeof visitor.fallback === 'function') {
|
||||
this.__fallback = visitor.fallback;
|
||||
}
|
||||
|
||||
this.__keys = VisitorKeys;
|
||||
if (visitor.keys) {
|
||||
this.__keys = Object.assign(Object.create(this.__keys), visitor.keys);
|
||||
}
|
||||
};
|
||||
|
||||
function isNode(node) {
|
||||
if (node == null) {
|
||||
return false;
|
||||
}
|
||||
return typeof node === 'object' && typeof node.type === 'string';
|
||||
}
|
||||
|
||||
function isProperty(nodeType, key) {
|
||||
return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
|
||||
}
|
||||
|
||||
function candidateExistsInLeaveList(leavelist, candidate) {
|
||||
for (var i = leavelist.length - 1; i >= 0; --i) {
|
||||
if (leavelist[i].node === candidate) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
Controller.prototype.traverse = function traverse(root, visitor) {
|
||||
var worklist,
|
||||
leavelist,
|
||||
element,
|
||||
node,
|
||||
nodeType,
|
||||
ret,
|
||||
key,
|
||||
current,
|
||||
current2,
|
||||
candidates,
|
||||
candidate,
|
||||
sentinel;
|
||||
|
||||
this.__initialize(root, visitor);
|
||||
|
||||
sentinel = {};
|
||||
|
||||
// reference
|
||||
worklist = this.__worklist;
|
||||
leavelist = this.__leavelist;
|
||||
|
||||
// initialize
|
||||
worklist.push(new Element(root, null, null, null));
|
||||
leavelist.push(new Element(null, null, null, null));
|
||||
|
||||
while (worklist.length) {
|
||||
element = worklist.pop();
|
||||
|
||||
if (element === sentinel) {
|
||||
element = leavelist.pop();
|
||||
|
||||
ret = this.__execute(visitor.leave, element);
|
||||
|
||||
if (this.__state === BREAK || ret === BREAK) {
|
||||
return;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (element.node) {
|
||||
|
||||
ret = this.__execute(visitor.enter, element);
|
||||
|
||||
if (this.__state === BREAK || ret === BREAK) {
|
||||
return;
|
||||
}
|
||||
|
||||
worklist.push(sentinel);
|
||||
leavelist.push(element);
|
||||
|
||||
if (this.__state === SKIP || ret === SKIP) {
|
||||
continue;
|
||||
}
|
||||
|
||||
node = element.node;
|
||||
nodeType = node.type || element.wrap;
|
||||
candidates = this.__keys[nodeType];
|
||||
if (!candidates) {
|
||||
if (this.__fallback) {
|
||||
candidates = this.__fallback(node);
|
||||
} else {
|
||||
throw new Error('Unknown node type ' + nodeType + '.');
|
||||
}
|
||||
}
|
||||
|
||||
current = candidates.length;
|
||||
while ((current -= 1) >= 0) {
|
||||
key = candidates[current];
|
||||
candidate = node[key];
|
||||
if (!candidate) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Array.isArray(candidate)) {
|
||||
current2 = candidate.length;
|
||||
while ((current2 -= 1) >= 0) {
|
||||
if (!candidate[current2]) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (candidateExistsInLeaveList(leavelist, candidate[current2])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (isProperty(nodeType, candidates[current])) {
|
||||
element = new Element(candidate[current2], [key, current2], 'Property', null);
|
||||
} else if (isNode(candidate[current2])) {
|
||||
element = new Element(candidate[current2], [key, current2], null, null);
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
worklist.push(element);
|
||||
}
|
||||
} else if (isNode(candidate)) {
|
||||
if (candidateExistsInLeaveList(leavelist, candidate)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
worklist.push(new Element(candidate, key, null, null));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Controller.prototype.replace = function replace(root, visitor) {
|
||||
var worklist,
|
||||
leavelist,
|
||||
node,
|
||||
nodeType,
|
||||
target,
|
||||
element,
|
||||
current,
|
||||
current2,
|
||||
candidates,
|
||||
candidate,
|
||||
sentinel,
|
||||
outer,
|
||||
key;
|
||||
|
||||
function removeElem(element) {
|
||||
var i,
|
||||
key,
|
||||
nextElem,
|
||||
parent;
|
||||
|
||||
if (element.ref.remove()) {
|
||||
// When the reference is an element of an array.
|
||||
key = element.ref.key;
|
||||
parent = element.ref.parent;
|
||||
|
||||
// If removed from array, then decrease following items' keys.
|
||||
i = worklist.length;
|
||||
while (i--) {
|
||||
nextElem = worklist[i];
|
||||
if (nextElem.ref && nextElem.ref.parent === parent) {
|
||||
if (nextElem.ref.key < key) {
|
||||
break;
|
||||
}
|
||||
--nextElem.ref.key;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this.__initialize(root, visitor);
|
||||
|
||||
sentinel = {};
|
||||
|
||||
// reference
|
||||
worklist = this.__worklist;
|
||||
leavelist = this.__leavelist;
|
||||
|
||||
// initialize
|
||||
outer = {
|
||||
root: root
|
||||
};
|
||||
element = new Element(root, null, null, new Reference(outer, 'root'));
|
||||
worklist.push(element);
|
||||
leavelist.push(element);
|
||||
|
||||
while (worklist.length) {
|
||||
element = worklist.pop();
|
||||
|
||||
if (element === sentinel) {
|
||||
element = leavelist.pop();
|
||||
|
||||
target = this.__execute(visitor.leave, element);
|
||||
|
||||
// node may be replaced with null,
|
||||
// so distinguish between undefined and null in this place
|
||||
if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
|
||||
// replace
|
||||
element.ref.replace(target);
|
||||
}
|
||||
|
||||
if (this.__state === REMOVE || target === REMOVE) {
|
||||
removeElem(element);
|
||||
}
|
||||
|
||||
if (this.__state === BREAK || target === BREAK) {
|
||||
return outer.root;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
target = this.__execute(visitor.enter, element);
|
||||
|
||||
// node may be replaced with null,
|
||||
// so distinguish between undefined and null in this place
|
||||
if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
|
||||
// replace
|
||||
element.ref.replace(target);
|
||||
element.node = target;
|
||||
}
|
||||
|
||||
if (this.__state === REMOVE || target === REMOVE) {
|
||||
removeElem(element);
|
||||
element.node = null;
|
||||
}
|
||||
|
||||
if (this.__state === BREAK || target === BREAK) {
|
||||
return outer.root;
|
||||
}
|
||||
|
||||
// node may be null
|
||||
node = element.node;
|
||||
if (!node) {
|
||||
continue;
|
||||
}
|
||||
|
||||
worklist.push(sentinel);
|
||||
leavelist.push(element);
|
||||
|
||||
if (this.__state === SKIP || target === SKIP) {
|
||||
continue;
|
||||
}
|
||||
|
||||
nodeType = node.type || element.wrap;
|
||||
candidates = this.__keys[nodeType];
|
||||
if (!candidates) {
|
||||
if (this.__fallback) {
|
||||
candidates = this.__fallback(node);
|
||||
} else {
|
||||
throw new Error('Unknown node type ' + nodeType + '.');
|
||||
}
|
||||
}
|
||||
|
||||
current = candidates.length;
|
||||
while ((current -= 1) >= 0) {
|
||||
key = candidates[current];
|
||||
candidate = node[key];
|
||||
if (!candidate) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Array.isArray(candidate)) {
|
||||
current2 = candidate.length;
|
||||
while ((current2 -= 1) >= 0) {
|
||||
if (!candidate[current2]) {
|
||||
continue;
|
||||
}
|
||||
if (isProperty(nodeType, candidates[current])) {
|
||||
element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
|
||||
} else if (isNode(candidate[current2])) {
|
||||
element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
worklist.push(element);
|
||||
}
|
||||
} else if (isNode(candidate)) {
|
||||
worklist.push(new Element(candidate, key, null, new Reference(node, key)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return outer.root;
|
||||
};
|
||||
|
||||
function traverse(root, visitor) {
|
||||
var controller = new Controller();
|
||||
return controller.traverse(root, visitor);
|
||||
}
|
||||
|
||||
function replace(root, visitor) {
|
||||
var controller = new Controller();
|
||||
return controller.replace(root, visitor);
|
||||
}
|
||||
|
||||
function extendCommentRange(comment, tokens) {
|
||||
var target;
|
||||
|
||||
target = upperBound(tokens, function search(token) {
|
||||
return token.range[0] > comment.range[0];
|
||||
});
|
||||
|
||||
comment.extendedRange = [comment.range[0], comment.range[1]];
|
||||
|
||||
if (target !== tokens.length) {
|
||||
comment.extendedRange[1] = tokens[target].range[0];
|
||||
}
|
||||
|
||||
target -= 1;
|
||||
if (target >= 0) {
|
||||
comment.extendedRange[0] = tokens[target].range[1];
|
||||
}
|
||||
|
||||
return comment;
|
||||
}
|
||||
|
||||
function attachComments(tree, providedComments, tokens) {
|
||||
// At first, we should calculate extended comment ranges.
|
||||
var comments = [], comment, len, i, cursor;
|
||||
|
||||
if (!tree.range) {
|
||||
throw new Error('attachComments needs range information');
|
||||
}
|
||||
|
||||
// tokens array is empty, we attach comments to tree as 'leadingComments'
|
||||
if (!tokens.length) {
|
||||
if (providedComments.length) {
|
||||
for (i = 0, len = providedComments.length; i < len; i += 1) {
|
||||
comment = deepCopy(providedComments[i]);
|
||||
comment.extendedRange = [0, tree.range[0]];
|
||||
comments.push(comment);
|
||||
}
|
||||
tree.leadingComments = comments;
|
||||
}
|
||||
return tree;
|
||||
}
|
||||
|
||||
for (i = 0, len = providedComments.length; i < len; i += 1) {
|
||||
comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
|
||||
}
|
||||
|
||||
// This is based on John Freeman's implementation.
|
||||
cursor = 0;
|
||||
traverse(tree, {
|
||||
enter: function (node) {
|
||||
var comment;
|
||||
|
||||
while (cursor < comments.length) {
|
||||
comment = comments[cursor];
|
||||
if (comment.extendedRange[1] > node.range[0]) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (comment.extendedRange[1] === node.range[0]) {
|
||||
if (!node.leadingComments) {
|
||||
node.leadingComments = [];
|
||||
}
|
||||
node.leadingComments.push(comment);
|
||||
comments.splice(cursor, 1);
|
||||
} else {
|
||||
cursor += 1;
|
||||
}
|
||||
}
|
||||
|
||||
// already out of owned node
|
||||
if (cursor === comments.length) {
|
||||
return VisitorOption.Break;
|
||||
}
|
||||
|
||||
if (comments[cursor].extendedRange[0] > node.range[1]) {
|
||||
return VisitorOption.Skip;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
cursor = 0;
|
||||
traverse(tree, {
|
||||
leave: function (node) {
|
||||
var comment;
|
||||
|
||||
while (cursor < comments.length) {
|
||||
comment = comments[cursor];
|
||||
if (node.range[1] < comment.extendedRange[0]) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (node.range[1] === comment.extendedRange[0]) {
|
||||
if (!node.trailingComments) {
|
||||
node.trailingComments = [];
|
||||
}
|
||||
node.trailingComments.push(comment);
|
||||
comments.splice(cursor, 1);
|
||||
} else {
|
||||
cursor += 1;
|
||||
}
|
||||
}
|
||||
|
||||
// already out of owned node
|
||||
if (cursor === comments.length) {
|
||||
return VisitorOption.Break;
|
||||
}
|
||||
|
||||
if (comments[cursor].extendedRange[0] > node.range[1]) {
|
||||
return VisitorOption.Skip;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
return tree;
|
||||
}
|
||||
|
||||
exports.Syntax = Syntax;
|
||||
exports.traverse = traverse;
|
||||
exports.replace = replace;
|
||||
exports.attachComments = attachComments;
|
||||
exports.VisitorKeys = VisitorKeys;
|
||||
exports.VisitorOption = VisitorOption;
|
||||
exports.Controller = Controller;
|
||||
exports.cloneEnvironment = function () { return clone({}); };
|
||||
|
||||
return exports;
|
||||
}(exports));
|
||||
/* vim: set sw=4 ts=4 et tw=80 : */
|
||||
});
|
||||
|
||||
export default estraverse;
|
||||
@ -1,890 +0,0 @@
|
||||
import { g as getDefaultExportFromCjs, c as createCommonjsModule } from './common/_commonjsHelpers-8c19dec8.js';
|
||||
|
||||
var fraction = createCommonjsModule(function (module, exports) {
|
||||
/**
|
||||
* @license Fraction.js v4.1.2 23/05/2021
|
||||
* https://www.xarg.org/2014/03/rational-numbers-in-javascript/
|
||||
*
|
||||
* Copyright (c) 2021, Robert Eisele (robert@xarg.org)
|
||||
* Dual licensed under the MIT or GPL Version 2 licenses.
|
||||
**/
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* This class offers the possibility to calculate fractions.
|
||||
* You can pass a fraction in different formats. Either as array, as double, as string or as an integer.
|
||||
*
|
||||
* Array/Object form
|
||||
* [ 0 => <nominator>, 1 => <denominator> ]
|
||||
* [ n => <nominator>, d => <denominator> ]
|
||||
*
|
||||
* Integer form
|
||||
* - Single integer value
|
||||
*
|
||||
* Double form
|
||||
* - Single double value
|
||||
*
|
||||
* String form
|
||||
* 123.456 - a simple double
|
||||
* 123/456 - a string fraction
|
||||
* 123.'456' - a double with repeating decimal places
|
||||
* 123.(456) - synonym
|
||||
* 123.45'6' - a double with repeating last place
|
||||
* 123.45(6) - synonym
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* var f = new Fraction("9.4'31'");
|
||||
* f.mul([-4, 3]).div(4.9);
|
||||
*
|
||||
*/
|
||||
|
||||
(function(root) {
|
||||
|
||||
// Maximum search depth for cyclic rational numbers. 2000 should be more than enough.
|
||||
// Example: 1/7 = 0.(142857) has 6 repeating decimal places.
|
||||
// If MAX_CYCLE_LEN gets reduced, long cycles will not be detected and toString() only gets the first 10 digits
|
||||
var MAX_CYCLE_LEN = 2000;
|
||||
|
||||
// Parsed data to avoid calling "new" all the time
|
||||
var P = {
|
||||
"s": 1,
|
||||
"n": 0,
|
||||
"d": 1
|
||||
};
|
||||
|
||||
function createError(name) {
|
||||
|
||||
function errorConstructor() {
|
||||
var temp = Error.apply(this, arguments);
|
||||
temp['name'] = this['name'] = name;
|
||||
this['stack'] = temp['stack'];
|
||||
this['message'] = temp['message'];
|
||||
}
|
||||
|
||||
/**
|
||||
* Error constructor
|
||||
*
|
||||
* @constructor
|
||||
*/
|
||||
function IntermediateInheritor() { }
|
||||
IntermediateInheritor.prototype = Error.prototype;
|
||||
errorConstructor.prototype = new IntermediateInheritor();
|
||||
|
||||
return errorConstructor;
|
||||
}
|
||||
|
||||
var DivisionByZero = Fraction['DivisionByZero'] = createError('DivisionByZero');
|
||||
var InvalidParameter = Fraction['InvalidParameter'] = createError('InvalidParameter');
|
||||
|
||||
function assign(n, s) {
|
||||
|
||||
if (isNaN(n = parseInt(n, 10))) {
|
||||
throwInvalidParam();
|
||||
}
|
||||
return n * s;
|
||||
}
|
||||
|
||||
function throwInvalidParam() {
|
||||
throw new InvalidParameter();
|
||||
}
|
||||
|
||||
function factorize(num) {
|
||||
|
||||
var factors = {};
|
||||
|
||||
var n = num;
|
||||
var i = 2;
|
||||
var s = 4;
|
||||
|
||||
while (s <= n) {
|
||||
|
||||
while (n % i === 0) {
|
||||
n /= i;
|
||||
factors[i] = (factors[i] || 0) + 1;
|
||||
}
|
||||
s += 1 + 2 * i++;
|
||||
}
|
||||
|
||||
if (n !== num) {
|
||||
if (n > 1)
|
||||
factors[n] = (factors[n] || 0) + 1;
|
||||
} else {
|
||||
factors[num] = (factors[num] || 0) + 1;
|
||||
}
|
||||
return factors;
|
||||
}
|
||||
|
||||
var parse = function(p1, p2) {
|
||||
|
||||
var n = 0, d = 1, s = 1;
|
||||
var v = 0, w = 0, x = 0, y = 1, z = 1;
|
||||
|
||||
var A = 0, B = 1;
|
||||
var C = 1, D = 1;
|
||||
|
||||
var N = 10000000;
|
||||
var M;
|
||||
|
||||
if (p1 === undefined || p1 === null) ; else if (p2 !== undefined) {
|
||||
n = p1;
|
||||
d = p2;
|
||||
s = n * d;
|
||||
} else
|
||||
switch (typeof p1) {
|
||||
|
||||
case "object":
|
||||
{
|
||||
if ("d" in p1 && "n" in p1) {
|
||||
n = p1["n"];
|
||||
d = p1["d"];
|
||||
if ("s" in p1)
|
||||
n *= p1["s"];
|
||||
} else if (0 in p1) {
|
||||
n = p1[0];
|
||||
if (1 in p1)
|
||||
d = p1[1];
|
||||
} else {
|
||||
throwInvalidParam();
|
||||
}
|
||||
s = n * d;
|
||||
break;
|
||||
}
|
||||
case "number":
|
||||
{
|
||||
if (p1 < 0) {
|
||||
s = p1;
|
||||
p1 = -p1;
|
||||
}
|
||||
|
||||
if (p1 % 1 === 0) {
|
||||
n = p1;
|
||||
} else if (p1 > 0) { // check for != 0, scale would become NaN (log(0)), which converges really slow
|
||||
|
||||
if (p1 >= 1) {
|
||||
z = Math.pow(10, Math.floor(1 + Math.log(p1) / Math.LN10));
|
||||
p1 /= z;
|
||||
}
|
||||
|
||||
// Using Farey Sequences
|
||||
// http://www.johndcook.com/blog/2010/10/20/best-rational-approximation/
|
||||
|
||||
while (B <= N && D <= N) {
|
||||
M = (A + C) / (B + D);
|
||||
|
||||
if (p1 === M) {
|
||||
if (B + D <= N) {
|
||||
n = A + C;
|
||||
d = B + D;
|
||||
} else if (D > B) {
|
||||
n = C;
|
||||
d = D;
|
||||
} else {
|
||||
n = A;
|
||||
d = B;
|
||||
}
|
||||
break;
|
||||
|
||||
} else {
|
||||
|
||||
if (p1 > M) {
|
||||
A += C;
|
||||
B += D;
|
||||
} else {
|
||||
C += A;
|
||||
D += B;
|
||||
}
|
||||
|
||||
if (B > N) {
|
||||
n = C;
|
||||
d = D;
|
||||
} else {
|
||||
n = A;
|
||||
d = B;
|
||||
}
|
||||
}
|
||||
}
|
||||
n *= z;
|
||||
} else if (isNaN(p1) || isNaN(p2)) {
|
||||
d = n = NaN;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case "string":
|
||||
{
|
||||
B = p1.match(/\d+|./g);
|
||||
|
||||
if (B === null)
|
||||
throwInvalidParam();
|
||||
|
||||
if (B[A] === '-') {// Check for minus sign at the beginning
|
||||
s = -1;
|
||||
A++;
|
||||
} else if (B[A] === '+') {// Check for plus sign at the beginning
|
||||
A++;
|
||||
}
|
||||
|
||||
if (B.length === A + 1) { // Check if it's just a simple number "1234"
|
||||
w = assign(B[A++], s);
|
||||
} else if (B[A + 1] === '.' || B[A] === '.') { // Check if it's a decimal number
|
||||
|
||||
if (B[A] !== '.') { // Handle 0.5 and .5
|
||||
v = assign(B[A++], s);
|
||||
}
|
||||
A++;
|
||||
|
||||
// Check for decimal places
|
||||
if (A + 1 === B.length || B[A + 1] === '(' && B[A + 3] === ')' || B[A + 1] === "'" && B[A + 3] === "'") {
|
||||
w = assign(B[A], s);
|
||||
y = Math.pow(10, B[A].length);
|
||||
A++;
|
||||
}
|
||||
|
||||
// Check for repeating places
|
||||
if (B[A] === '(' && B[A + 2] === ')' || B[A] === "'" && B[A + 2] === "'") {
|
||||
x = assign(B[A + 1], s);
|
||||
z = Math.pow(10, B[A + 1].length) - 1;
|
||||
A += 3;
|
||||
}
|
||||
|
||||
} else if (B[A + 1] === '/' || B[A + 1] === ':') { // Check for a simple fraction "123/456" or "123:456"
|
||||
w = assign(B[A], s);
|
||||
y = assign(B[A + 2], 1);
|
||||
A += 3;
|
||||
} else if (B[A + 3] === '/' && B[A + 1] === ' ') { // Check for a complex fraction "123 1/2"
|
||||
v = assign(B[A], s);
|
||||
w = assign(B[A + 2], s);
|
||||
y = assign(B[A + 4], 1);
|
||||
A += 5;
|
||||
}
|
||||
|
||||
if (B.length <= A) { // Check for more tokens on the stack
|
||||
d = y * z;
|
||||
s = /* void */
|
||||
n = x + d * v + z * w;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Fall through on error */
|
||||
}
|
||||
default:
|
||||
throwInvalidParam();
|
||||
}
|
||||
|
||||
if (d === 0) {
|
||||
throw new DivisionByZero();
|
||||
}
|
||||
|
||||
P["s"] = s < 0 ? -1 : 1;
|
||||
P["n"] = Math.abs(n);
|
||||
P["d"] = Math.abs(d);
|
||||
};
|
||||
|
||||
function modpow(b, e, m) {
|
||||
|
||||
var r = 1;
|
||||
for (; e > 0; b = (b * b) % m, e >>= 1) {
|
||||
|
||||
if (e & 1) {
|
||||
r = (r * b) % m;
|
||||
}
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
function cycleLen(n, d) {
|
||||
|
||||
for (; d % 2 === 0;
|
||||
d /= 2) {
|
||||
}
|
||||
|
||||
for (; d % 5 === 0;
|
||||
d /= 5) {
|
||||
}
|
||||
|
||||
if (d === 1) // Catch non-cyclic numbers
|
||||
return 0;
|
||||
|
||||
// If we would like to compute really large numbers quicker, we could make use of Fermat's little theorem:
|
||||
// 10^(d-1) % d == 1
|
||||
// However, we don't need such large numbers and MAX_CYCLE_LEN should be the capstone,
|
||||
// as we want to translate the numbers to strings.
|
||||
|
||||
var rem = 10 % d;
|
||||
var t = 1;
|
||||
|
||||
for (; rem !== 1; t++) {
|
||||
rem = rem * 10 % d;
|
||||
|
||||
if (t > MAX_CYCLE_LEN)
|
||||
return 0; // Returning 0 here means that we don't print it as a cyclic number. It's likely that the answer is `d-1`
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
|
||||
function cycleStart(n, d, len) {
|
||||
|
||||
var rem1 = 1;
|
||||
var rem2 = modpow(10, len, d);
|
||||
|
||||
for (var t = 0; t < 300; t++) { // s < ~log10(Number.MAX_VALUE)
|
||||
// Solve 10^s == 10^(s+t) (mod d)
|
||||
|
||||
if (rem1 === rem2)
|
||||
return t;
|
||||
|
||||
rem1 = rem1 * 10 % d;
|
||||
rem2 = rem2 * 10 % d;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
function gcd(a, b) {
|
||||
|
||||
if (!a)
|
||||
return b;
|
||||
if (!b)
|
||||
return a;
|
||||
|
||||
while (1) {
|
||||
a %= b;
|
||||
if (!a)
|
||||
return b;
|
||||
b %= a;
|
||||
if (!b)
|
||||
return a;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Module constructor
|
||||
*
|
||||
* @constructor
|
||||
* @param {number|Fraction=} a
|
||||
* @param {number=} b
|
||||
*/
|
||||
function Fraction(a, b) {
|
||||
|
||||
if (!(this instanceof Fraction)) {
|
||||
return new Fraction(a, b);
|
||||
}
|
||||
|
||||
parse(a, b);
|
||||
|
||||
a = gcd(P["d"], P["n"]); // Abuse variable a
|
||||
|
||||
this["s"] = P["s"];
|
||||
this["n"] = P["n"] / a;
|
||||
this["d"] = P["d"] / a;
|
||||
}
|
||||
|
||||
Fraction.prototype = {
|
||||
|
||||
"s": 1,
|
||||
"n": 0,
|
||||
"d": 1,
|
||||
|
||||
/**
|
||||
* Calculates the absolute value
|
||||
*
|
||||
* Ex: new Fraction(-4).abs() => 4
|
||||
**/
|
||||
"abs": function() {
|
||||
|
||||
return new Fraction(this["n"], this["d"]);
|
||||
},
|
||||
|
||||
/**
|
||||
* Inverts the sign of the current fraction
|
||||
*
|
||||
* Ex: new Fraction(-4).neg() => 4
|
||||
**/
|
||||
"neg": function() {
|
||||
|
||||
return new Fraction(-this["s"] * this["n"], this["d"]);
|
||||
},
|
||||
|
||||
/**
|
||||
* Adds two rational numbers
|
||||
*
|
||||
* Ex: new Fraction({n: 2, d: 3}).add("14.9") => 467 / 30
|
||||
**/
|
||||
"add": function(a, b) {
|
||||
|
||||
parse(a, b);
|
||||
return new Fraction(
|
||||
this["s"] * this["n"] * P["d"] + P["s"] * this["d"] * P["n"],
|
||||
this["d"] * P["d"]
|
||||
);
|
||||
},
|
||||
|
||||
/**
|
||||
* Subtracts two rational numbers
|
||||
*
|
||||
* Ex: new Fraction({n: 2, d: 3}).add("14.9") => -427 / 30
|
||||
**/
|
||||
"sub": function(a, b) {
|
||||
|
||||
parse(a, b);
|
||||
return new Fraction(
|
||||
this["s"] * this["n"] * P["d"] - P["s"] * this["d"] * P["n"],
|
||||
this["d"] * P["d"]
|
||||
);
|
||||
},
|
||||
|
||||
/**
|
||||
* Multiplies two rational numbers
|
||||
*
|
||||
* Ex: new Fraction("-17.(345)").mul(3) => 5776 / 111
|
||||
**/
|
||||
"mul": function(a, b) {
|
||||
|
||||
parse(a, b);
|
||||
return new Fraction(
|
||||
this["s"] * P["s"] * this["n"] * P["n"],
|
||||
this["d"] * P["d"]
|
||||
);
|
||||
},
|
||||
|
||||
/**
|
||||
* Divides two rational numbers
|
||||
*
|
||||
* Ex: new Fraction("-17.(345)").inverse().div(3)
|
||||
**/
|
||||
"div": function(a, b) {
|
||||
|
||||
parse(a, b);
|
||||
return new Fraction(
|
||||
this["s"] * P["s"] * this["n"] * P["d"],
|
||||
this["d"] * P["n"]
|
||||
);
|
||||
},
|
||||
|
||||
/**
|
||||
* Clones the actual object
|
||||
*
|
||||
* Ex: new Fraction("-17.(345)").clone()
|
||||
**/
|
||||
"clone": function() {
|
||||
return new Fraction(this);
|
||||
},
|
||||
|
||||
/**
|
||||
* Calculates the modulo of two rational numbers - a more precise fmod
|
||||
*
|
||||
* Ex: new Fraction('4.(3)').mod([7, 8]) => (13/3) % (7/8) = (5/6)
|
||||
**/
|
||||
"mod": function(a, b) {
|
||||
|
||||
if (isNaN(this['n']) || isNaN(this['d'])) {
|
||||
return new Fraction(NaN);
|
||||
}
|
||||
|
||||
if (a === undefined) {
|
||||
return new Fraction(this["s"] * this["n"] % this["d"], 1);
|
||||
}
|
||||
|
||||
parse(a, b);
|
||||
if (0 === P["n"] && 0 === this["d"]) {
|
||||
Fraction(0, 0); // Throw DivisionByZero
|
||||
}
|
||||
|
||||
/*
|
||||
* First silly attempt, kinda slow
|
||||
*
|
||||
return that["sub"]({
|
||||
"n": num["n"] * Math.floor((this.n / this.d) / (num.n / num.d)),
|
||||
"d": num["d"],
|
||||
"s": this["s"]
|
||||
});*/
|
||||
|
||||
/*
|
||||
* New attempt: a1 / b1 = a2 / b2 * q + r
|
||||
* => b2 * a1 = a2 * b1 * q + b1 * b2 * r
|
||||
* => (b2 * a1 % a2 * b1) / (b1 * b2)
|
||||
*/
|
||||
return new Fraction(
|
||||
this["s"] * (P["d"] * this["n"]) % (P["n"] * this["d"]),
|
||||
P["d"] * this["d"]
|
||||
);
|
||||
},
|
||||
|
||||
/**
|
||||
* Calculates the fractional gcd of two rational numbers
|
||||
*
|
||||
* Ex: new Fraction(5,8).gcd(3,7) => 1/56
|
||||
*/
|
||||
"gcd": function(a, b) {
|
||||
|
||||
parse(a, b);
|
||||
|
||||
// gcd(a / b, c / d) = gcd(a, c) / lcm(b, d)
|
||||
|
||||
return new Fraction(gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]), P["d"] * this["d"]);
|
||||
},
|
||||
|
||||
/**
|
||||
* Calculates the fractional lcm of two rational numbers
|
||||
*
|
||||
* Ex: new Fraction(5,8).lcm(3,7) => 15
|
||||
*/
|
||||
"lcm": function(a, b) {
|
||||
|
||||
parse(a, b);
|
||||
|
||||
// lcm(a / b, c / d) = lcm(a, c) / gcd(b, d)
|
||||
|
||||
if (P["n"] === 0 && this["n"] === 0) {
|
||||
return new Fraction;
|
||||
}
|
||||
return new Fraction(P["n"] * this["n"], gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]));
|
||||
},
|
||||
|
||||
/**
|
||||
* Calculates the ceil of a rational number
|
||||
*
|
||||
* Ex: new Fraction('4.(3)').ceil() => (5 / 1)
|
||||
**/
|
||||
"ceil": function(places) {
|
||||
|
||||
places = Math.pow(10, places || 0);
|
||||
|
||||
if (isNaN(this["n"]) || isNaN(this["d"])) {
|
||||
return new Fraction(NaN);
|
||||
}
|
||||
return new Fraction(Math.ceil(places * this["s"] * this["n"] / this["d"]), places);
|
||||
},
|
||||
|
||||
/**
|
||||
* Calculates the floor of a rational number
|
||||
*
|
||||
* Ex: new Fraction('4.(3)').floor() => (4 / 1)
|
||||
**/
|
||||
"floor": function(places) {
|
||||
|
||||
places = Math.pow(10, places || 0);
|
||||
|
||||
if (isNaN(this["n"]) || isNaN(this["d"])) {
|
||||
return new Fraction(NaN);
|
||||
}
|
||||
return new Fraction(Math.floor(places * this["s"] * this["n"] / this["d"]), places);
|
||||
},
|
||||
|
||||
/**
|
||||
* Rounds a rational numbers
|
||||
*
|
||||
* Ex: new Fraction('4.(3)').round() => (4 / 1)
|
||||
**/
|
||||
"round": function(places) {
|
||||
|
||||
places = Math.pow(10, places || 0);
|
||||
|
||||
if (isNaN(this["n"]) || isNaN(this["d"])) {
|
||||
return new Fraction(NaN);
|
||||
}
|
||||
return new Fraction(Math.round(places * this["s"] * this["n"] / this["d"]), places);
|
||||
},
|
||||
|
||||
/**
|
||||
* Gets the inverse of the fraction, means numerator and denominator are exchanged
|
||||
*
|
||||
* Ex: new Fraction([-3, 4]).inverse() => -4 / 3
|
||||
**/
|
||||
"inverse": function() {
|
||||
|
||||
return new Fraction(this["s"] * this["d"], this["n"]);
|
||||
},
|
||||
|
||||
/**
|
||||
* Calculates the fraction to some rational exponent, if possible
|
||||
*
|
||||
* Ex: new Fraction(-1,2).pow(-3) => -8
|
||||
*/
|
||||
"pow": function(a, b) {
|
||||
|
||||
parse(a, b);
|
||||
|
||||
// Trivial case when exp is an integer
|
||||
|
||||
if (P['d'] === 1) {
|
||||
|
||||
if (P['s'] < 0) {
|
||||
return new Fraction(Math.pow(this['s'] * this["d"], P['n']), Math.pow(this["n"], P['n']));
|
||||
} else {
|
||||
return new Fraction(Math.pow(this['s'] * this["n"], P['n']), Math.pow(this["d"], P['n']));
|
||||
}
|
||||
}
|
||||
|
||||
// Negative roots become complex
|
||||
// (-a/b)^(c/d) = x
|
||||
// <=> (-1)^(c/d) * (a/b)^(c/d) = x
|
||||
// <=> (cos(pi) + i*sin(pi))^(c/d) * (a/b)^(c/d) = x # rotate 1 by 180°
|
||||
// <=> (cos(c*pi/d) + i*sin(c*pi/d)) * (a/b)^(c/d) = x # DeMoivre's formula in Q ( https://proofwiki.org/wiki/De_Moivre%27s_Formula/Rational_Index )
|
||||
// From which follows that only for c=0 the root is non-complex. c/d is a reduced fraction, so that sin(c/dpi)=0 occurs for d=1, which is handled by our trivial case.
|
||||
if (this['s'] < 0) return null;
|
||||
|
||||
// Now prime factor n and d
|
||||
var N = factorize(this['n']);
|
||||
var D = factorize(this['d']);
|
||||
|
||||
// Exponentiate and take root for n and d individually
|
||||
var n = 1;
|
||||
var d = 1;
|
||||
for (var k in N) {
|
||||
if (k === '1') continue;
|
||||
if (k === '0') {
|
||||
n = 0;
|
||||
break;
|
||||
}
|
||||
N[k]*= P['n'];
|
||||
|
||||
if (N[k] % P['d'] === 0) {
|
||||
N[k]/= P['d'];
|
||||
} else return null;
|
||||
n*= Math.pow(k, N[k]);
|
||||
}
|
||||
|
||||
for (var k in D) {
|
||||
if (k === '1') continue;
|
||||
D[k]*= P['n'];
|
||||
|
||||
if (D[k] % P['d'] === 0) {
|
||||
D[k]/= P['d'];
|
||||
} else return null;
|
||||
d*= Math.pow(k, D[k]);
|
||||
}
|
||||
|
||||
if (P['s'] < 0) {
|
||||
return new Fraction(d, n);
|
||||
}
|
||||
return new Fraction(n, d);
|
||||
},
|
||||
|
||||
/**
|
||||
* Check if two rational numbers are the same
|
||||
*
|
||||
* Ex: new Fraction(19.6).equals([98, 5]);
|
||||
**/
|
||||
"equals": function(a, b) {
|
||||
|
||||
parse(a, b);
|
||||
return this["s"] * this["n"] * P["d"] === P["s"] * P["n"] * this["d"]; // Same as compare() === 0
|
||||
},
|
||||
|
||||
/**
|
||||
* Check if two rational numbers are the same
|
||||
*
|
||||
* Ex: new Fraction(19.6).equals([98, 5]);
|
||||
**/
|
||||
"compare": function(a, b) {
|
||||
|
||||
parse(a, b);
|
||||
var t = (this["s"] * this["n"] * P["d"] - P["s"] * P["n"] * this["d"]);
|
||||
return (0 < t) - (t < 0);
|
||||
},
|
||||
|
||||
"simplify": function(eps) {
|
||||
|
||||
// First naive implementation, needs improvement
|
||||
|
||||
if (isNaN(this['n']) || isNaN(this['d'])) {
|
||||
return this;
|
||||
}
|
||||
|
||||
var cont = this['abs']()['toContinued']();
|
||||
|
||||
eps = eps || 0.001;
|
||||
|
||||
function rec(a) {
|
||||
if (a.length === 1)
|
||||
return new Fraction(a[0]);
|
||||
return rec(a.slice(1))['inverse']()['add'](a[0]);
|
||||
}
|
||||
|
||||
for (var i = 0; i < cont.length; i++) {
|
||||
var tmp = rec(cont.slice(0, i + 1));
|
||||
if (tmp['sub'](this['abs']())['abs']().valueOf() < eps) {
|
||||
return tmp['mul'](this['s']);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
},
|
||||
|
||||
/**
|
||||
* Check if two rational numbers are divisible
|
||||
*
|
||||
* Ex: new Fraction(19.6).divisible(1.5);
|
||||
*/
|
||||
"divisible": function(a, b) {
|
||||
|
||||
parse(a, b);
|
||||
return !(!(P["n"] * this["d"]) || ((this["n"] * P["d"]) % (P["n"] * this["d"])));
|
||||
},
|
||||
|
||||
/**
|
||||
* Returns a decimal representation of the fraction
|
||||
*
|
||||
* Ex: new Fraction("100.'91823'").valueOf() => 100.91823918239183
|
||||
**/
|
||||
'valueOf': function() {
|
||||
|
||||
return this["s"] * this["n"] / this["d"];
|
||||
},
|
||||
|
||||
/**
|
||||
* Returns a string-fraction representation of a Fraction object
|
||||
*
|
||||
* Ex: new Fraction("1.'3'").toFraction() => "4 1/3"
|
||||
**/
|
||||
'toFraction': function(excludeWhole) {
|
||||
|
||||
var whole, str = "";
|
||||
var n = this["n"];
|
||||
var d = this["d"];
|
||||
if (this["s"] < 0) {
|
||||
str += '-';
|
||||
}
|
||||
|
||||
if (d === 1) {
|
||||
str += n;
|
||||
} else {
|
||||
|
||||
if (excludeWhole && (whole = Math.floor(n / d)) > 0) {
|
||||
str += whole;
|
||||
str += " ";
|
||||
n %= d;
|
||||
}
|
||||
|
||||
str += n;
|
||||
str += '/';
|
||||
str += d;
|
||||
}
|
||||
return str;
|
||||
},
|
||||
|
||||
/**
|
||||
* Returns a latex representation of a Fraction object
|
||||
*
|
||||
* Ex: new Fraction("1.'3'").toLatex() => "\frac{4}{3}"
|
||||
**/
|
||||
'toLatex': function(excludeWhole) {
|
||||
|
||||
var whole, str = "";
|
||||
var n = this["n"];
|
||||
var d = this["d"];
|
||||
if (this["s"] < 0) {
|
||||
str += '-';
|
||||
}
|
||||
|
||||
if (d === 1) {
|
||||
str += n;
|
||||
} else {
|
||||
|
||||
if (excludeWhole && (whole = Math.floor(n / d)) > 0) {
|
||||
str += whole;
|
||||
n %= d;
|
||||
}
|
||||
|
||||
str += "\\frac{";
|
||||
str += n;
|
||||
str += '}{';
|
||||
str += d;
|
||||
str += '}';
|
||||
}
|
||||
return str;
|
||||
},
|
||||
|
||||
/**
|
||||
* Returns an array of continued fraction elements
|
||||
*
|
||||
* Ex: new Fraction("7/8").toContinued() => [0,1,7]
|
||||
*/
|
||||
'toContinued': function() {
|
||||
|
||||
var t;
|
||||
var a = this['n'];
|
||||
var b = this['d'];
|
||||
var res = [];
|
||||
|
||||
if (isNaN(a) || isNaN(b)) {
|
||||
return res;
|
||||
}
|
||||
|
||||
do {
|
||||
res.push(Math.floor(a / b));
|
||||
t = a % b;
|
||||
a = b;
|
||||
b = t;
|
||||
} while (a !== 1);
|
||||
|
||||
return res;
|
||||
},
|
||||
|
||||
/**
|
||||
* Creates a string representation of a fraction with all digits
|
||||
*
|
||||
* Ex: new Fraction("100.'91823'").toString() => "100.(91823)"
|
||||
**/
|
||||
'toString': function(dec) {
|
||||
var N = this["n"];
|
||||
var D = this["d"];
|
||||
|
||||
if (isNaN(N) || isNaN(D)) {
|
||||
return "NaN";
|
||||
}
|
||||
|
||||
dec = dec || 15; // 15 = decimal places when no repetation
|
||||
|
||||
var cycLen = cycleLen(N, D); // Cycle length
|
||||
var cycOff = cycleStart(N, D, cycLen); // Cycle start
|
||||
|
||||
var str = this['s'] === -1 ? "-" : "";
|
||||
|
||||
str += N / D | 0;
|
||||
|
||||
N %= D;
|
||||
N *= 10;
|
||||
|
||||
if (N)
|
||||
str += ".";
|
||||
|
||||
if (cycLen) {
|
||||
|
||||
for (var i = cycOff; i--;) {
|
||||
str += N / D | 0;
|
||||
N %= D;
|
||||
N *= 10;
|
||||
}
|
||||
str += "(";
|
||||
for (var i = cycLen; i--;) {
|
||||
str += N / D | 0;
|
||||
N %= D;
|
||||
N *= 10;
|
||||
}
|
||||
str += ")";
|
||||
} else {
|
||||
for (var i = dec; N && i--;) {
|
||||
str += N / D | 0;
|
||||
N %= D;
|
||||
N *= 10;
|
||||
}
|
||||
}
|
||||
return str;
|
||||
}
|
||||
};
|
||||
|
||||
{
|
||||
Object.defineProperty(Fraction, "__esModule", { 'value': true });
|
||||
Fraction['default'] = Fraction;
|
||||
Fraction['Fraction'] = Fraction;
|
||||
module['exports'] = Fraction;
|
||||
}
|
||||
|
||||
})();
|
||||
});
|
||||
|
||||
var __pika_web_default_export_for_treeshaking__ = /*@__PURE__*/getDefaultExportFromCjs(fraction);
|
||||
|
||||
export default __pika_web_default_export_for_treeshaking__;
|
||||
@ -1,25 +0,0 @@
|
||||
{
|
||||
"imports": {
|
||||
"@tonaljs/tonal": "./@tonaljs/tonal.js",
|
||||
"@tonejs/piano": "./@tonejs/piano.js",
|
||||
"bjork": "./bjork.js",
|
||||
"chord-voicings": "./chord-voicings.js",
|
||||
"codemirror/lib/codemirror.css": "./codemirror/lib/codemirror.css",
|
||||
"codemirror/mode/javascript/javascript.js": "./codemirror/mode/javascript/javascript.js",
|
||||
"codemirror/mode/pegjs/pegjs.js": "./codemirror/mode/pegjs/pegjs.js",
|
||||
"codemirror/theme/material.css": "./codemirror/theme/material.css",
|
||||
"estraverse": "./estraverse.js",
|
||||
"fraction.js": "./fractionjs.js",
|
||||
"multimap": "./multimap.js",
|
||||
"ramda": "./ramda.js",
|
||||
"react": "./react.js",
|
||||
"react-codemirror2": "./react-codemirror2.js",
|
||||
"react-dom": "./react-dom.js",
|
||||
"shift-ast": "./shift-ast.js",
|
||||
"shift-codegen": "./shift-codegen.js",
|
||||
"shift-regexp-acceptor": "./shift-regexp-acceptor.js",
|
||||
"shift-spec": "./shift-spec.js",
|
||||
"tone": "./tone.js",
|
||||
"webmidi": "./webmidi.js"
|
||||
}
|
||||
}
|
||||
@ -1,229 +0,0 @@
|
||||
import { c as createCommonjsModule } from './common/_commonjsHelpers-8c19dec8.js';
|
||||
|
||||
var multimap = createCommonjsModule(function (module, exports) {
|
||||
|
||||
/* global module, define */
|
||||
|
||||
function mapEach(map, operation){
|
||||
var keys = map.keys();
|
||||
var next;
|
||||
while(!(next = keys.next()).done) {
|
||||
operation(map.get(next.value), next.value, map);
|
||||
}
|
||||
}
|
||||
|
||||
var Multimap = (function() {
|
||||
var mapCtor;
|
||||
if (typeof Map !== 'undefined') {
|
||||
mapCtor = Map;
|
||||
|
||||
if (!Map.prototype.keys) {
|
||||
Map.prototype.keys = function() {
|
||||
var keys = [];
|
||||
this.forEach(function(item, key) {
|
||||
keys.push(key);
|
||||
});
|
||||
return keys;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
function Multimap(iterable) {
|
||||
var self = this;
|
||||
|
||||
self._map = mapCtor;
|
||||
|
||||
if (Multimap.Map) {
|
||||
self._map = Multimap.Map;
|
||||
}
|
||||
|
||||
self._ = self._map ? new self._map() : {};
|
||||
|
||||
if (iterable) {
|
||||
iterable.forEach(function(i) {
|
||||
self.set(i[0], i[1]);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {Object} key
|
||||
* @return {Array} An array of values, undefined if no such a key;
|
||||
*/
|
||||
Multimap.prototype.get = function(key) {
|
||||
return this._map ? this._.get(key) : this._[key];
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {Object} key
|
||||
* @param {Object} val...
|
||||
*/
|
||||
Multimap.prototype.set = function(key, val) {
|
||||
var args = Array.prototype.slice.call(arguments);
|
||||
|
||||
key = args.shift();
|
||||
|
||||
var entry = this.get(key);
|
||||
if (!entry) {
|
||||
entry = [];
|
||||
if (this._map)
|
||||
this._.set(key, entry);
|
||||
else
|
||||
this._[key] = entry;
|
||||
}
|
||||
|
||||
Array.prototype.push.apply(entry, args);
|
||||
return this;
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {Object} key
|
||||
* @param {Object=} val
|
||||
* @return {boolean} true if any thing changed
|
||||
*/
|
||||
Multimap.prototype.delete = function(key, val) {
|
||||
if (!this.has(key))
|
||||
return false;
|
||||
|
||||
if (arguments.length == 1) {
|
||||
this._map ? (this._.delete(key)) : (delete this._[key]);
|
||||
return true;
|
||||
} else {
|
||||
var entry = this.get(key);
|
||||
var idx = entry.indexOf(val);
|
||||
if (idx != -1) {
|
||||
entry.splice(idx, 1);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {Object} key
|
||||
* @param {Object=} val
|
||||
* @return {boolean} whether the map contains 'key' or 'key=>val' pair
|
||||
*/
|
||||
Multimap.prototype.has = function(key, val) {
|
||||
var hasKey = this._map ? this._.has(key) : this._.hasOwnProperty(key);
|
||||
|
||||
if (arguments.length == 1 || !hasKey)
|
||||
return hasKey;
|
||||
|
||||
var entry = this.get(key) || [];
|
||||
return entry.indexOf(val) != -1;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {Array} all the keys in the map
|
||||
*/
|
||||
Multimap.prototype.keys = function() {
|
||||
if (this._map)
|
||||
return makeIterator(this._.keys());
|
||||
|
||||
return makeIterator(Object.keys(this._));
|
||||
};
|
||||
|
||||
/**
|
||||
* @return {Array} all the values in the map
|
||||
*/
|
||||
Multimap.prototype.values = function() {
|
||||
var vals = [];
|
||||
this.forEachEntry(function(entry) {
|
||||
Array.prototype.push.apply(vals, entry);
|
||||
});
|
||||
|
||||
return makeIterator(vals);
|
||||
};
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
Multimap.prototype.forEachEntry = function(iter) {
|
||||
mapEach(this, iter);
|
||||
};
|
||||
|
||||
Multimap.prototype.forEach = function(iter) {
|
||||
var self = this;
|
||||
self.forEachEntry(function(entry, key) {
|
||||
entry.forEach(function(item) {
|
||||
iter(item, key, self);
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
|
||||
Multimap.prototype.clear = function() {
|
||||
if (this._map) {
|
||||
this._.clear();
|
||||
} else {
|
||||
this._ = {};
|
||||
}
|
||||
};
|
||||
|
||||
Object.defineProperty(
|
||||
Multimap.prototype,
|
||||
"size", {
|
||||
configurable: false,
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
var total = 0;
|
||||
|
||||
mapEach(this, function(value){
|
||||
total += value.length;
|
||||
});
|
||||
|
||||
return total;
|
||||
}
|
||||
});
|
||||
|
||||
Object.defineProperty(
|
||||
Multimap.prototype,
|
||||
"count", {
|
||||
configurable: false,
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return this._.size;
|
||||
}
|
||||
});
|
||||
|
||||
var safariNext;
|
||||
|
||||
try{
|
||||
safariNext = new Function('iterator', 'makeIterator', 'var keysArray = []; for(var key of iterator){keysArray.push(key);} return makeIterator(keysArray).next;');
|
||||
}catch(error){
|
||||
// for of not implemented;
|
||||
}
|
||||
|
||||
function makeIterator(iterator){
|
||||
if(Array.isArray(iterator)){
|
||||
var nextIndex = 0;
|
||||
|
||||
return {
|
||||
next: function(){
|
||||
return nextIndex < iterator.length ?
|
||||
{value: iterator[nextIndex++], done: false} :
|
||||
{done: true};
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Only an issue in safari
|
||||
if(!iterator.next && safariNext){
|
||||
iterator.next = safariNext(iterator, makeIterator);
|
||||
}
|
||||
|
||||
return iterator;
|
||||
}
|
||||
|
||||
return Multimap;
|
||||
})();
|
||||
|
||||
|
||||
if( module && module.exports)
|
||||
module.exports = Multimap;
|
||||
});
|
||||
|
||||
export default multimap;
|
||||
@ -1,606 +0,0 @@
|
||||
function _isPlaceholder(a) {
|
||||
return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimized internal one-arity curry function.
|
||||
*
|
||||
* @private
|
||||
* @category Function
|
||||
* @param {Function} fn The function to curry.
|
||||
* @return {Function} The curried function.
|
||||
*/
|
||||
|
||||
function _curry1(fn) {
|
||||
return function f1(a) {
|
||||
if (arguments.length === 0 || _isPlaceholder(a)) {
|
||||
return f1;
|
||||
} else {
|
||||
return fn.apply(this, arguments);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimized internal two-arity curry function.
|
||||
*
|
||||
* @private
|
||||
* @category Function
|
||||
* @param {Function} fn The function to curry.
|
||||
* @return {Function} The curried function.
|
||||
*/
|
||||
|
||||
function _curry2(fn) {
|
||||
return function f2(a, b) {
|
||||
switch (arguments.length) {
|
||||
case 0:
|
||||
return f2;
|
||||
|
||||
case 1:
|
||||
return _isPlaceholder(a) ? f2 : _curry1(function (_b) {
|
||||
return fn(a, _b);
|
||||
});
|
||||
|
||||
default:
|
||||
return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function (_a) {
|
||||
return fn(_a, b);
|
||||
}) : _isPlaceholder(b) ? _curry1(function (_b) {
|
||||
return fn(a, _b);
|
||||
}) : fn(a, b);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function _arity(n, fn) {
|
||||
/* eslint-disable no-unused-vars */
|
||||
switch (n) {
|
||||
case 0:
|
||||
return function () {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
case 1:
|
||||
return function (a0) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
case 2:
|
||||
return function (a0, a1) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
case 3:
|
||||
return function (a0, a1, a2) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
case 4:
|
||||
return function (a0, a1, a2, a3) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
case 5:
|
||||
return function (a0, a1, a2, a3, a4) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
case 6:
|
||||
return function (a0, a1, a2, a3, a4, a5) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
case 7:
|
||||
return function (a0, a1, a2, a3, a4, a5, a6) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
case 8:
|
||||
return function (a0, a1, a2, a3, a4, a5, a6, a7) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
case 9:
|
||||
return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
case 10:
|
||||
return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
default:
|
||||
throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimized internal three-arity curry function.
|
||||
*
|
||||
* @private
|
||||
* @category Function
|
||||
* @param {Function} fn The function to curry.
|
||||
* @return {Function} The curried function.
|
||||
*/
|
||||
|
||||
function _curry3(fn) {
|
||||
return function f3(a, b, c) {
|
||||
switch (arguments.length) {
|
||||
case 0:
|
||||
return f3;
|
||||
|
||||
case 1:
|
||||
return _isPlaceholder(a) ? f3 : _curry2(function (_b, _c) {
|
||||
return fn(a, _b, _c);
|
||||
});
|
||||
|
||||
case 2:
|
||||
return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function (_a, _c) {
|
||||
return fn(_a, b, _c);
|
||||
}) : _isPlaceholder(b) ? _curry2(function (_b, _c) {
|
||||
return fn(a, _b, _c);
|
||||
}) : _curry1(function (_c) {
|
||||
return fn(a, b, _c);
|
||||
});
|
||||
|
||||
default:
|
||||
return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function (_a, _b) {
|
||||
return fn(_a, _b, c);
|
||||
}) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function (_a, _c) {
|
||||
return fn(_a, b, _c);
|
||||
}) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function (_b, _c) {
|
||||
return fn(a, _b, _c);
|
||||
}) : _isPlaceholder(a) ? _curry1(function (_a) {
|
||||
return fn(_a, b, c);
|
||||
}) : _isPlaceholder(b) ? _curry1(function (_b) {
|
||||
return fn(a, _b, c);
|
||||
}) : _isPlaceholder(c) ? _curry1(function (_c) {
|
||||
return fn(a, b, _c);
|
||||
}) : fn(a, b, c);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests whether or not an object is an array.
|
||||
*
|
||||
* @private
|
||||
* @param {*} val The object to test.
|
||||
* @return {Boolean} `true` if `val` is an array, `false` otherwise.
|
||||
* @example
|
||||
*
|
||||
* _isArray([]); //=> true
|
||||
* _isArray(null); //=> false
|
||||
* _isArray({}); //=> false
|
||||
*/
|
||||
var _isArray = Array.isArray || function _isArray(val) {
|
||||
return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';
|
||||
};
|
||||
|
||||
function _isString(x) {
|
||||
return Object.prototype.toString.call(x) === '[object String]';
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests whether or not an object is similar to an array.
|
||||
*
|
||||
* @private
|
||||
* @category Type
|
||||
* @category List
|
||||
* @sig * -> Boolean
|
||||
* @param {*} x The object to test.
|
||||
* @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.
|
||||
* @example
|
||||
*
|
||||
* _isArrayLike([]); //=> true
|
||||
* _isArrayLike(true); //=> false
|
||||
* _isArrayLike({}); //=> false
|
||||
* _isArrayLike({length: 10}); //=> false
|
||||
* _isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true
|
||||
* _isArrayLike({nodeType: 1, length: 1}) // => false
|
||||
*/
|
||||
|
||||
var _isArrayLike =
|
||||
/*#__PURE__*/
|
||||
_curry1(function isArrayLike(x) {
|
||||
if (_isArray(x)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!x) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (typeof x !== 'object') {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (_isString(x)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (x.length === 0) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (x.length > 0) {
|
||||
return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);
|
||||
}
|
||||
|
||||
return false;
|
||||
});
|
||||
|
||||
var XWrap =
|
||||
/*#__PURE__*/
|
||||
function () {
|
||||
function XWrap(fn) {
|
||||
this.f = fn;
|
||||
}
|
||||
|
||||
XWrap.prototype['@@transducer/init'] = function () {
|
||||
throw new Error('init not implemented on XWrap');
|
||||
};
|
||||
|
||||
XWrap.prototype['@@transducer/result'] = function (acc) {
|
||||
return acc;
|
||||
};
|
||||
|
||||
XWrap.prototype['@@transducer/step'] = function (acc, x) {
|
||||
return this.f(acc, x);
|
||||
};
|
||||
|
||||
return XWrap;
|
||||
}();
|
||||
|
||||
function _xwrap(fn) {
|
||||
return new XWrap(fn);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a function that is bound to a context.
|
||||
* Note: `R.bind` does not provide the additional argument-binding capabilities of
|
||||
* [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).
|
||||
*
|
||||
* @func
|
||||
* @memberOf R
|
||||
* @since v0.6.0
|
||||
* @category Function
|
||||
* @category Object
|
||||
* @sig (* -> *) -> {*} -> (* -> *)
|
||||
* @param {Function} fn The function to bind to context
|
||||
* @param {Object} thisObj The context to bind `fn` to
|
||||
* @return {Function} A function that will execute in the context of `thisObj`.
|
||||
* @see R.partial
|
||||
* @example
|
||||
*
|
||||
* const log = R.bind(console.log, console);
|
||||
* R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}
|
||||
* // logs {a: 2}
|
||||
* @symb R.bind(f, o)(a, b) = f.call(o, a, b)
|
||||
*/
|
||||
|
||||
var bind =
|
||||
/*#__PURE__*/
|
||||
_curry2(function bind(fn, thisObj) {
|
||||
return _arity(fn.length, function () {
|
||||
return fn.apply(thisObj, arguments);
|
||||
});
|
||||
});
|
||||
|
||||
function _arrayReduce(xf, acc, list) {
|
||||
var idx = 0;
|
||||
var len = list.length;
|
||||
|
||||
while (idx < len) {
|
||||
acc = xf['@@transducer/step'](acc, list[idx]);
|
||||
|
||||
if (acc && acc['@@transducer/reduced']) {
|
||||
acc = acc['@@transducer/value'];
|
||||
break;
|
||||
}
|
||||
|
||||
idx += 1;
|
||||
}
|
||||
|
||||
return xf['@@transducer/result'](acc);
|
||||
}
|
||||
|
||||
function _iterableReduce(xf, acc, iter) {
|
||||
var step = iter.next();
|
||||
|
||||
while (!step.done) {
|
||||
acc = xf['@@transducer/step'](acc, step.value);
|
||||
|
||||
if (acc && acc['@@transducer/reduced']) {
|
||||
acc = acc['@@transducer/value'];
|
||||
break;
|
||||
}
|
||||
|
||||
step = iter.next();
|
||||
}
|
||||
|
||||
return xf['@@transducer/result'](acc);
|
||||
}
|
||||
|
||||
function _methodReduce(xf, acc, obj, methodName) {
|
||||
return xf['@@transducer/result'](obj[methodName](bind(xf['@@transducer/step'], xf), acc));
|
||||
}
|
||||
|
||||
var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';
|
||||
function _reduce(fn, acc, list) {
|
||||
if (typeof fn === 'function') {
|
||||
fn = _xwrap(fn);
|
||||
}
|
||||
|
||||
if (_isArrayLike(list)) {
|
||||
return _arrayReduce(fn, acc, list);
|
||||
}
|
||||
|
||||
if (typeof list['fantasy-land/reduce'] === 'function') {
|
||||
return _methodReduce(fn, acc, list, 'fantasy-land/reduce');
|
||||
}
|
||||
|
||||
if (list[symIterator] != null) {
|
||||
return _iterableReduce(fn, acc, list[symIterator]());
|
||||
}
|
||||
|
||||
if (typeof list.next === 'function') {
|
||||
return _iterableReduce(fn, acc, list);
|
||||
}
|
||||
|
||||
if (typeof list.reduce === 'function') {
|
||||
return _methodReduce(fn, acc, list, 'reduce');
|
||||
}
|
||||
|
||||
throw new TypeError('reduce: list must be array or iterable');
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a single item by iterating through the list, successively calling
|
||||
* the iterator function and passing it an accumulator value and the current
|
||||
* value from the array, and then passing the result to the next call.
|
||||
*
|
||||
* The iterator function receives two values: *(acc, value)*. It may use
|
||||
* [`R.reduced`](#reduced) to shortcut the iteration.
|
||||
*
|
||||
* The arguments' order of [`reduceRight`](#reduceRight)'s iterator function
|
||||
* is *(value, acc)*.
|
||||
*
|
||||
* Note: `R.reduce` does not skip deleted or unassigned indices (sparse
|
||||
* arrays), unlike the native `Array.prototype.reduce` method. For more details
|
||||
* on this behavior, see:
|
||||
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description
|
||||
*
|
||||
* Dispatches to the `reduce` method of the third argument, if present. When
|
||||
* doing so, it is up to the user to handle the [`R.reduced`](#reduced)
|
||||
* shortcuting, as this is not implemented by `reduce`.
|
||||
*
|
||||
* @func
|
||||
* @memberOf R
|
||||
* @since v0.1.0
|
||||
* @category List
|
||||
* @sig ((a, b) -> a) -> a -> [b] -> a
|
||||
* @param {Function} fn The iterator function. Receives two values, the accumulator and the
|
||||
* current element from the array.
|
||||
* @param {*} acc The accumulator value.
|
||||
* @param {Array} list The list to iterate over.
|
||||
* @return {*} The final, accumulated value.
|
||||
* @see R.reduced, R.addIndex, R.reduceRight
|
||||
* @example
|
||||
*
|
||||
* R.reduce(R.subtract, 0, [1, 2, 3, 4]) // => ((((0 - 1) - 2) - 3) - 4) = -10
|
||||
* // - -10
|
||||
* // / \ / \
|
||||
* // - 4 -6 4
|
||||
* // / \ / \
|
||||
* // - 3 ==> -3 3
|
||||
* // / \ / \
|
||||
* // - 2 -1 2
|
||||
* // / \ / \
|
||||
* // 0 1 0 1
|
||||
*
|
||||
* @symb R.reduce(f, a, [b, c, d]) = f(f(f(a, b), c), d)
|
||||
*/
|
||||
|
||||
var reduce =
|
||||
/*#__PURE__*/
|
||||
_curry3(_reduce);
|
||||
|
||||
function _pipe(f, g) {
|
||||
return function () {
|
||||
return g.call(this, f.apply(this, arguments));
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* This checks whether a function has a [methodname] function. If it isn't an
|
||||
* array it will execute that function otherwise it will default to the ramda
|
||||
* implementation.
|
||||
*
|
||||
* @private
|
||||
* @param {Function} fn ramda implementation
|
||||
* @param {String} methodname property to check for a custom implementation
|
||||
* @return {Object} Whatever the return value of the method is.
|
||||
*/
|
||||
|
||||
function _checkForMethod(methodname, fn) {
|
||||
return function () {
|
||||
var length = arguments.length;
|
||||
|
||||
if (length === 0) {
|
||||
return fn();
|
||||
}
|
||||
|
||||
var obj = arguments[length - 1];
|
||||
return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the elements of the given list or string (or object with a `slice`
|
||||
* method) from `fromIndex` (inclusive) to `toIndex` (exclusive).
|
||||
*
|
||||
* Dispatches to the `slice` method of the third argument, if present.
|
||||
*
|
||||
* @func
|
||||
* @memberOf R
|
||||
* @since v0.1.4
|
||||
* @category List
|
||||
* @sig Number -> Number -> [a] -> [a]
|
||||
* @sig Number -> Number -> String -> String
|
||||
* @param {Number} fromIndex The start index (inclusive).
|
||||
* @param {Number} toIndex The end index (exclusive).
|
||||
* @param {*} list
|
||||
* @return {*}
|
||||
* @example
|
||||
*
|
||||
* R.slice(1, 3, ['a', 'b', 'c', 'd']); //=> ['b', 'c']
|
||||
* R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']
|
||||
* R.slice(0, -1, ['a', 'b', 'c', 'd']); //=> ['a', 'b', 'c']
|
||||
* R.slice(-3, -1, ['a', 'b', 'c', 'd']); //=> ['b', 'c']
|
||||
* R.slice(0, 3, 'ramda'); //=> 'ram'
|
||||
*/
|
||||
|
||||
var slice =
|
||||
/*#__PURE__*/
|
||||
_curry3(
|
||||
/*#__PURE__*/
|
||||
_checkForMethod('slice', function slice(fromIndex, toIndex, list) {
|
||||
return Array.prototype.slice.call(list, fromIndex, toIndex);
|
||||
}));
|
||||
|
||||
/**
|
||||
* Returns all but the first element of the given list or string (or object
|
||||
* with a `tail` method).
|
||||
*
|
||||
* Dispatches to the `slice` method of the first argument, if present.
|
||||
*
|
||||
* @func
|
||||
* @memberOf R
|
||||
* @since v0.1.0
|
||||
* @category List
|
||||
* @sig [a] -> [a]
|
||||
* @sig String -> String
|
||||
* @param {*} list
|
||||
* @return {*}
|
||||
* @see R.head, R.init, R.last
|
||||
* @example
|
||||
*
|
||||
* R.tail([1, 2, 3]); //=> [2, 3]
|
||||
* R.tail([1, 2]); //=> [2]
|
||||
* R.tail([1]); //=> []
|
||||
* R.tail([]); //=> []
|
||||
*
|
||||
* R.tail('abc'); //=> 'bc'
|
||||
* R.tail('ab'); //=> 'b'
|
||||
* R.tail('a'); //=> ''
|
||||
* R.tail(''); //=> ''
|
||||
*/
|
||||
|
||||
var tail =
|
||||
/*#__PURE__*/
|
||||
_curry1(
|
||||
/*#__PURE__*/
|
||||
_checkForMethod('tail',
|
||||
/*#__PURE__*/
|
||||
slice(1, Infinity)));
|
||||
|
||||
/**
|
||||
* Performs left-to-right function composition. The first argument may have
|
||||
* any arity; the remaining arguments must be unary.
|
||||
*
|
||||
* In some libraries this function is named `sequence`.
|
||||
*
|
||||
* **Note:** The result of pipe is not automatically curried.
|
||||
*
|
||||
* @func
|
||||
* @memberOf R
|
||||
* @since v0.1.0
|
||||
* @category Function
|
||||
* @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> ((a, b, ..., n) -> z)
|
||||
* @param {...Function} functions
|
||||
* @return {Function}
|
||||
* @see R.compose
|
||||
* @example
|
||||
*
|
||||
* const f = R.pipe(Math.pow, R.negate, R.inc);
|
||||
*
|
||||
* f(3, 4); // -(3^4) + 1
|
||||
* @symb R.pipe(f, g, h)(a, b) = h(g(f(a, b)))
|
||||
* @symb R.pipe(f, g, h)(a)(b) = h(g(f(a)))(b)
|
||||
*/
|
||||
|
||||
function pipe() {
|
||||
if (arguments.length === 0) {
|
||||
throw new Error('pipe requires at least one argument');
|
||||
}
|
||||
|
||||
return _arity(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a new list or string with the elements or characters in reverse
|
||||
* order.
|
||||
*
|
||||
* @func
|
||||
* @memberOf R
|
||||
* @since v0.1.0
|
||||
* @category List
|
||||
* @sig [a] -> [a]
|
||||
* @sig String -> String
|
||||
* @param {Array|String} list
|
||||
* @return {Array|String}
|
||||
* @example
|
||||
*
|
||||
* R.reverse([1, 2, 3]); //=> [3, 2, 1]
|
||||
* R.reverse([1, 2]); //=> [2, 1]
|
||||
* R.reverse([1]); //=> [1]
|
||||
* R.reverse([]); //=> []
|
||||
*
|
||||
* R.reverse('abc'); //=> 'cba'
|
||||
* R.reverse('ab'); //=> 'ba'
|
||||
* R.reverse('a'); //=> 'a'
|
||||
* R.reverse(''); //=> ''
|
||||
*/
|
||||
|
||||
var reverse =
|
||||
/*#__PURE__*/
|
||||
_curry1(function reverse(list) {
|
||||
return _isString(list) ? list.split('').reverse().join('') : Array.prototype.slice.call(list, 0).reverse();
|
||||
});
|
||||
|
||||
/**
|
||||
* Performs right-to-left function composition. The last argument may have
|
||||
* any arity; the remaining arguments must be unary.
|
||||
*
|
||||
* **Note:** The result of compose is not automatically curried.
|
||||
*
|
||||
* @func
|
||||
* @memberOf R
|
||||
* @since v0.1.0
|
||||
* @category Function
|
||||
* @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> ((a, b, ..., n) -> z)
|
||||
* @param {...Function} ...functions The functions to compose
|
||||
* @return {Function}
|
||||
* @see R.pipe
|
||||
* @example
|
||||
*
|
||||
* const classyGreeting = (firstName, lastName) => "The name's " + lastName + ", " + firstName + " " + lastName
|
||||
* const yellGreeting = R.compose(R.toUpper, classyGreeting);
|
||||
* yellGreeting('James', 'Bond'); //=> "THE NAME'S BOND, JAMES BOND"
|
||||
*
|
||||
* R.compose(Math.abs, R.add(1), R.multiply(2))(-4) //=> 7
|
||||
*
|
||||
* @symb R.compose(f, g, h)(a, b) = f(g(h(a, b)))
|
||||
* @symb R.compose(f, g, h)(a)(b) = f(g(h(a)))(b)
|
||||
*/
|
||||
|
||||
function compose() {
|
||||
if (arguments.length === 0) {
|
||||
throw new Error('compose requires at least one argument');
|
||||
}
|
||||
|
||||
return pipe.apply(this, reverse(arguments));
|
||||
}
|
||||
|
||||
export { compose };
|
||||
789
docs/_snowpack/pkg/react-codemirror2.js
vendored
789
docs/_snowpack/pkg/react-codemirror2.js
vendored
@ -1,789 +0,0 @@
|
||||
import { c as createCommonjsModule, a as commonjsGlobal } from './common/_commonjsHelpers-8c19dec8.js';
|
||||
import { r as react } from './common/index-67cfdec9.js';
|
||||
import { c as codemirror } from './common/codemirror-d650d44d.js';
|
||||
import './common/index-d01087d6.js';
|
||||
|
||||
var reactCodemirror2 = createCommonjsModule(function (module, exports) {
|
||||
|
||||
function _extends() {
|
||||
_extends = Object.assign || function(target) {
|
||||
for (var i = 1; i < arguments.length; i++) {
|
||||
var source = arguments[i];
|
||||
for (var key in source) {
|
||||
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
||||
target[key] = source[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
return target;
|
||||
};
|
||||
return _extends.apply(this, arguments);
|
||||
}
|
||||
|
||||
function _typeof(obj) {
|
||||
"@babel/helpers - typeof";
|
||||
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
|
||||
_typeof = function _typeof(obj) {
|
||||
return typeof obj;
|
||||
};
|
||||
} else {
|
||||
_typeof = function _typeof(obj) {
|
||||
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
||||
};
|
||||
}
|
||||
return _typeof(obj);
|
||||
}
|
||||
|
||||
var __extends = function() {
|
||||
var _extendStatics = function extendStatics(d, b) {
|
||||
_extendStatics = Object.setPrototypeOf || {
|
||||
__proto__: []
|
||||
}
|
||||
instanceof Array && function(d, b) {
|
||||
d.__proto__ = b;
|
||||
} || function(d, b) {
|
||||
for (var p in b) {
|
||||
if (b.hasOwnProperty(p)) d[p] = b[p];
|
||||
}
|
||||
};
|
||||
|
||||
return _extendStatics(d, b);
|
||||
};
|
||||
|
||||
return function(d, b) {
|
||||
_extendStatics(d, b);
|
||||
|
||||
function __() {
|
||||
this.constructor = d;
|
||||
}
|
||||
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
}();
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.UnControlled = exports.Controlled = void 0;
|
||||
|
||||
|
||||
|
||||
var SERVER_RENDERED = typeof navigator === 'undefined' || commonjsGlobal['PREVENT_CODEMIRROR_RENDER'] === true;
|
||||
var cm;
|
||||
|
||||
if (!SERVER_RENDERED) {
|
||||
cm = codemirror;
|
||||
}
|
||||
|
||||
var Helper = function() {
|
||||
function Helper() {}
|
||||
|
||||
Helper.equals = function(x, y) {
|
||||
var _this = this;
|
||||
|
||||
var ok = Object.keys,
|
||||
tx = _typeof(x),
|
||||
ty = _typeof(y);
|
||||
|
||||
return x && y && tx === 'object' && tx === ty ? ok(x).length === ok(y).length && ok(x).every(function(key) {
|
||||
return _this.equals(x[key], y[key]);
|
||||
}) : x === y;
|
||||
};
|
||||
|
||||
return Helper;
|
||||
}();
|
||||
|
||||
var Shared = function() {
|
||||
function Shared(editor, props) {
|
||||
this.editor = editor;
|
||||
this.props = props;
|
||||
}
|
||||
|
||||
Shared.prototype.delegateCursor = function(position, scroll, focus) {
|
||||
var doc = this.editor.getDoc();
|
||||
|
||||
if (focus) {
|
||||
this.editor.focus();
|
||||
}
|
||||
|
||||
scroll ? doc.setCursor(position) : doc.setCursor(position, null, {
|
||||
scroll: false
|
||||
});
|
||||
};
|
||||
|
||||
Shared.prototype.delegateScroll = function(coordinates) {
|
||||
this.editor.scrollTo(coordinates.x, coordinates.y);
|
||||
};
|
||||
|
||||
Shared.prototype.delegateSelection = function(ranges, focus) {
|
||||
var doc = this.editor.getDoc();
|
||||
doc.setSelections(ranges);
|
||||
|
||||
if (focus) {
|
||||
this.editor.focus();
|
||||
}
|
||||
};
|
||||
|
||||
Shared.prototype.apply = function(props) {
|
||||
if (props && props.selection && props.selection.ranges) {
|
||||
this.delegateSelection(props.selection.ranges, props.selection.focus || false);
|
||||
}
|
||||
|
||||
if (props && props.cursor) {
|
||||
this.delegateCursor(props.cursor, props.autoScroll || false, this.editor.getOption('autofocus') || false);
|
||||
}
|
||||
|
||||
if (props && props.scroll) {
|
||||
this.delegateScroll(props.scroll);
|
||||
}
|
||||
};
|
||||
|
||||
Shared.prototype.applyNext = function(props, next, preserved) {
|
||||
if (props && props.selection && props.selection.ranges) {
|
||||
if (next && next.selection && next.selection.ranges && !Helper.equals(props.selection.ranges, next.selection.ranges)) {
|
||||
this.delegateSelection(next.selection.ranges, next.selection.focus || false);
|
||||
}
|
||||
}
|
||||
|
||||
if (props && props.cursor) {
|
||||
if (next && next.cursor && !Helper.equals(props.cursor, next.cursor)) {
|
||||
this.delegateCursor(preserved.cursor || next.cursor, next.autoScroll || false, next.autoCursor || false);
|
||||
}
|
||||
}
|
||||
|
||||
if (props && props.scroll) {
|
||||
if (next && next.scroll && !Helper.equals(props.scroll, next.scroll)) {
|
||||
this.delegateScroll(next.scroll);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Shared.prototype.applyUserDefined = function(props, preserved) {
|
||||
if (preserved && preserved.cursor) {
|
||||
this.delegateCursor(preserved.cursor, props.autoScroll || false, this.editor.getOption('autofocus') || false);
|
||||
}
|
||||
};
|
||||
|
||||
Shared.prototype.wire = function(props) {
|
||||
var _this = this;
|
||||
|
||||
Object.keys(props || {}).filter(function(p) {
|
||||
return /^on/.test(p);
|
||||
}).forEach(function(prop) {
|
||||
switch (prop) {
|
||||
case 'onBlur': {
|
||||
_this.editor.on('blur', function(cm, event) {
|
||||
_this.props.onBlur(_this.editor, event);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onContextMenu': {
|
||||
_this.editor.on('contextmenu', function(cm, event) {
|
||||
_this.props.onContextMenu(_this.editor, event);
|
||||
});
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 'onCopy': {
|
||||
_this.editor.on('copy', function(cm, event) {
|
||||
_this.props.onCopy(_this.editor, event);
|
||||
});
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 'onCursor': {
|
||||
_this.editor.on('cursorActivity', function(cm) {
|
||||
_this.props.onCursor(_this.editor, _this.editor.getDoc().getCursor());
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onCursorActivity': {
|
||||
_this.editor.on('cursorActivity', function(cm) {
|
||||
_this.props.onCursorActivity(_this.editor);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onCut': {
|
||||
_this.editor.on('cut', function(cm, event) {
|
||||
_this.props.onCut(_this.editor, event);
|
||||
});
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 'onDblClick': {
|
||||
_this.editor.on('dblclick', function(cm, event) {
|
||||
_this.props.onDblClick(_this.editor, event);
|
||||
});
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 'onDragEnter': {
|
||||
_this.editor.on('dragenter', function(cm, event) {
|
||||
_this.props.onDragEnter(_this.editor, event);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onDragLeave': {
|
||||
_this.editor.on('dragleave', function(cm, event) {
|
||||
_this.props.onDragLeave(_this.editor, event);
|
||||
});
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 'onDragOver': {
|
||||
_this.editor.on('dragover', function(cm, event) {
|
||||
_this.props.onDragOver(_this.editor, event);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onDragStart': {
|
||||
_this.editor.on('dragstart', function(cm, event) {
|
||||
_this.props.onDragStart(_this.editor, event);
|
||||
});
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 'onDrop': {
|
||||
_this.editor.on('drop', function(cm, event) {
|
||||
_this.props.onDrop(_this.editor, event);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onFocus': {
|
||||
_this.editor.on('focus', function(cm, event) {
|
||||
_this.props.onFocus(_this.editor, event);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onGutterClick': {
|
||||
_this.editor.on('gutterClick', function(cm, lineNumber, gutter, event) {
|
||||
_this.props.onGutterClick(_this.editor, lineNumber, gutter, event);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onInputRead': {
|
||||
_this.editor.on('inputRead', function(cm, EditorChangeEvent) {
|
||||
_this.props.onInputRead(_this.editor, EditorChangeEvent);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onKeyDown': {
|
||||
_this.editor.on('keydown', function(cm, event) {
|
||||
_this.props.onKeyDown(_this.editor, event);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onKeyHandled': {
|
||||
_this.editor.on('keyHandled', function(cm, key, event) {
|
||||
_this.props.onKeyHandled(_this.editor, key, event);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onKeyPress': {
|
||||
_this.editor.on('keypress', function(cm, event) {
|
||||
_this.props.onKeyPress(_this.editor, event);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onKeyUp': {
|
||||
_this.editor.on('keyup', function(cm, event) {
|
||||
_this.props.onKeyUp(_this.editor, event);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onMouseDown': {
|
||||
_this.editor.on('mousedown', function(cm, event) {
|
||||
_this.props.onMouseDown(_this.editor, event);
|
||||
});
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 'onPaste': {
|
||||
_this.editor.on('paste', function(cm, event) {
|
||||
_this.props.onPaste(_this.editor, event);
|
||||
});
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 'onRenderLine': {
|
||||
_this.editor.on('renderLine', function(cm, line, element) {
|
||||
_this.props.onRenderLine(_this.editor, line, element);
|
||||
});
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 'onScroll': {
|
||||
_this.editor.on('scroll', function(cm) {
|
||||
_this.props.onScroll(_this.editor, _this.editor.getScrollInfo());
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onSelection': {
|
||||
_this.editor.on('beforeSelectionChange', function(cm, data) {
|
||||
_this.props.onSelection(_this.editor, data);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onTouchStart': {
|
||||
_this.editor.on('touchstart', function(cm, event) {
|
||||
_this.props.onTouchStart(_this.editor, event);
|
||||
});
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 'onUpdate': {
|
||||
_this.editor.on('update', function(cm) {
|
||||
_this.props.onUpdate(_this.editor);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'onViewportChange': {
|
||||
_this.editor.on('viewportChange', function(cm, from, to) {
|
||||
_this.props.onViewportChange(_this.editor, from, to);
|
||||
});
|
||||
}
|
||||
break;
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
return Shared;
|
||||
}();
|
||||
|
||||
var Controlled = function(_super) {
|
||||
__extends(Controlled, _super);
|
||||
|
||||
function Controlled(props) {
|
||||
var _this = _super.call(this, props) || this;
|
||||
|
||||
if (SERVER_RENDERED) return _this;
|
||||
_this.applied = false;
|
||||
_this.appliedNext = false;
|
||||
_this.appliedUserDefined = false;
|
||||
_this.deferred = null;
|
||||
_this.emulating = false;
|
||||
_this.hydrated = false;
|
||||
|
||||
_this.initCb = function() {
|
||||
if (_this.props.editorDidConfigure) {
|
||||
_this.props.editorDidConfigure(_this.editor);
|
||||
}
|
||||
};
|
||||
|
||||
_this.mounted = false;
|
||||
return _this;
|
||||
}
|
||||
|
||||
Controlled.prototype.hydrate = function(props) {
|
||||
var _this = this;
|
||||
|
||||
var _options = props && props.options ? props.options : {};
|
||||
|
||||
var userDefinedOptions = _extends({}, cm.defaults, this.editor.options, _options);
|
||||
|
||||
var optionDelta = Object.keys(userDefinedOptions).some(function(key) {
|
||||
return _this.editor.getOption(key) !== userDefinedOptions[key];
|
||||
});
|
||||
|
||||
if (optionDelta) {
|
||||
Object.keys(userDefinedOptions).forEach(function(key) {
|
||||
if (_options.hasOwnProperty(key)) {
|
||||
if (_this.editor.getOption(key) !== userDefinedOptions[key]) {
|
||||
_this.editor.setOption(key, userDefinedOptions[key]);
|
||||
|
||||
_this.mirror.setOption(key, userDefinedOptions[key]);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (!this.hydrated) {
|
||||
this.deferred ? this.resolveChange(props.value) : this.initChange(props.value || '');
|
||||
}
|
||||
|
||||
this.hydrated = true;
|
||||
};
|
||||
|
||||
Controlled.prototype.initChange = function(value) {
|
||||
this.emulating = true;
|
||||
var doc = this.editor.getDoc();
|
||||
var lastLine = doc.lastLine();
|
||||
var lastChar = doc.getLine(doc.lastLine()).length;
|
||||
doc.replaceRange(value || '', {
|
||||
line: 0,
|
||||
ch: 0
|
||||
}, {
|
||||
line: lastLine,
|
||||
ch: lastChar
|
||||
});
|
||||
this.mirror.setValue(value);
|
||||
doc.clearHistory();
|
||||
this.mirror.clearHistory();
|
||||
this.emulating = false;
|
||||
};
|
||||
|
||||
Controlled.prototype.resolveChange = function(value) {
|
||||
this.emulating = true;
|
||||
var doc = this.editor.getDoc();
|
||||
|
||||
if (this.deferred.origin === 'undo') {
|
||||
doc.undo();
|
||||
} else if (this.deferred.origin === 'redo') {
|
||||
doc.redo();
|
||||
} else {
|
||||
doc.replaceRange(this.deferred.text, this.deferred.from, this.deferred.to, this.deferred.origin);
|
||||
}
|
||||
|
||||
if (value && value !== doc.getValue()) {
|
||||
var cursor = doc.getCursor();
|
||||
doc.setValue(value);
|
||||
doc.setCursor(cursor);
|
||||
}
|
||||
|
||||
this.emulating = false;
|
||||
this.deferred = null;
|
||||
};
|
||||
|
||||
Controlled.prototype.mirrorChange = function(deferred) {
|
||||
var doc = this.editor.getDoc();
|
||||
|
||||
if (deferred.origin === 'undo') {
|
||||
doc.setHistory(this.mirror.getHistory());
|
||||
this.mirror.undo();
|
||||
} else if (deferred.origin === 'redo') {
|
||||
doc.setHistory(this.mirror.getHistory());
|
||||
this.mirror.redo();
|
||||
} else {
|
||||
this.mirror.replaceRange(deferred.text, deferred.from, deferred.to, deferred.origin);
|
||||
}
|
||||
|
||||
return this.mirror.getValue();
|
||||
};
|
||||
|
||||
Controlled.prototype.componentDidMount = function() {
|
||||
var _this = this;
|
||||
|
||||
if (SERVER_RENDERED) return;
|
||||
|
||||
if (this.props.defineMode) {
|
||||
if (this.props.defineMode.name && this.props.defineMode.fn) {
|
||||
cm.defineMode(this.props.defineMode.name, this.props.defineMode.fn);
|
||||
}
|
||||
}
|
||||
|
||||
this.editor = cm(this.ref, this.props.options);
|
||||
this.shared = new Shared(this.editor, this.props);
|
||||
this.mirror = cm(function() {}, this.props.options);
|
||||
this.editor.on('electricInput', function() {
|
||||
_this.mirror.setHistory(_this.editor.getDoc().getHistory());
|
||||
});
|
||||
this.editor.on('cursorActivity', function() {
|
||||
_this.mirror.setCursor(_this.editor.getDoc().getCursor());
|
||||
});
|
||||
this.editor.on('beforeChange', function(cm, data) {
|
||||
if (_this.emulating) {
|
||||
return;
|
||||
}
|
||||
|
||||
data.cancel();
|
||||
_this.deferred = data;
|
||||
|
||||
var phantomChange = _this.mirrorChange(_this.deferred);
|
||||
|
||||
if (_this.props.onBeforeChange) _this.props.onBeforeChange(_this.editor, _this.deferred, phantomChange);
|
||||
});
|
||||
this.editor.on('change', function(cm, data) {
|
||||
if (!_this.mounted) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (_this.props.onChange) {
|
||||
_this.props.onChange(_this.editor, data, _this.editor.getValue());
|
||||
}
|
||||
});
|
||||
this.hydrate(this.props);
|
||||
this.shared.apply(this.props);
|
||||
this.applied = true;
|
||||
this.mounted = true;
|
||||
this.shared.wire(this.props);
|
||||
|
||||
if (this.editor.getOption('autofocus')) {
|
||||
this.editor.focus();
|
||||
}
|
||||
|
||||
if (this.props.editorDidMount) {
|
||||
this.props.editorDidMount(this.editor, this.editor.getValue(), this.initCb);
|
||||
}
|
||||
};
|
||||
|
||||
Controlled.prototype.componentDidUpdate = function(prevProps) {
|
||||
if (SERVER_RENDERED) return;
|
||||
var preserved = {
|
||||
cursor: null
|
||||
};
|
||||
|
||||
if (this.props.value !== prevProps.value) {
|
||||
this.hydrated = false;
|
||||
}
|
||||
|
||||
if (!this.props.autoCursor && this.props.autoCursor !== undefined) {
|
||||
preserved.cursor = this.editor.getDoc().getCursor();
|
||||
}
|
||||
|
||||
this.hydrate(this.props);
|
||||
|
||||
if (!this.appliedNext) {
|
||||
this.shared.applyNext(prevProps, this.props, preserved);
|
||||
this.appliedNext = true;
|
||||
}
|
||||
|
||||
this.shared.applyUserDefined(prevProps, preserved);
|
||||
this.appliedUserDefined = true;
|
||||
};
|
||||
|
||||
Controlled.prototype.componentWillUnmount = function() {
|
||||
if (SERVER_RENDERED) return;
|
||||
|
||||
if (this.props.editorWillUnmount) {
|
||||
this.props.editorWillUnmount(cm);
|
||||
}
|
||||
};
|
||||
|
||||
Controlled.prototype.shouldComponentUpdate = function(nextProps, nextState) {
|
||||
return !SERVER_RENDERED;
|
||||
};
|
||||
|
||||
Controlled.prototype.render = function() {
|
||||
var _this = this;
|
||||
|
||||
if (SERVER_RENDERED) return null;
|
||||
var className = this.props.className ? 'react-codemirror2 ' + this.props.className : 'react-codemirror2';
|
||||
return react.createElement('div', {
|
||||
className: className,
|
||||
ref: function ref(self) {
|
||||
return _this.ref = self;
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
return Controlled;
|
||||
}(react.Component);
|
||||
|
||||
exports.Controlled = Controlled;
|
||||
|
||||
var UnControlled = function(_super) {
|
||||
__extends(UnControlled, _super);
|
||||
|
||||
function UnControlled(props) {
|
||||
var _this = _super.call(this, props) || this;
|
||||
|
||||
if (SERVER_RENDERED) return _this;
|
||||
_this.applied = false;
|
||||
_this.appliedUserDefined = false;
|
||||
_this.continueChange = false;
|
||||
_this.detached = false;
|
||||
_this.hydrated = false;
|
||||
|
||||
_this.initCb = function() {
|
||||
if (_this.props.editorDidConfigure) {
|
||||
_this.props.editorDidConfigure(_this.editor);
|
||||
}
|
||||
};
|
||||
|
||||
_this.mounted = false;
|
||||
|
||||
_this.onBeforeChangeCb = function() {
|
||||
_this.continueChange = true;
|
||||
};
|
||||
|
||||
return _this;
|
||||
}
|
||||
|
||||
UnControlled.prototype.hydrate = function(props) {
|
||||
var _this = this;
|
||||
|
||||
var _options = props && props.options ? props.options : {};
|
||||
|
||||
var userDefinedOptions = _extends({}, cm.defaults, this.editor.options, _options);
|
||||
|
||||
var optionDelta = Object.keys(userDefinedOptions).some(function(key) {
|
||||
return _this.editor.getOption(key) !== userDefinedOptions[key];
|
||||
});
|
||||
|
||||
if (optionDelta) {
|
||||
Object.keys(userDefinedOptions).forEach(function(key) {
|
||||
if (_options.hasOwnProperty(key)) {
|
||||
if (_this.editor.getOption(key) !== userDefinedOptions[key]) {
|
||||
_this.editor.setOption(key, userDefinedOptions[key]);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (!this.hydrated) {
|
||||
var doc = this.editor.getDoc();
|
||||
var lastLine = doc.lastLine();
|
||||
var lastChar = doc.getLine(doc.lastLine()).length;
|
||||
doc.replaceRange(props.value || '', {
|
||||
line: 0,
|
||||
ch: 0
|
||||
}, {
|
||||
line: lastLine,
|
||||
ch: lastChar
|
||||
});
|
||||
}
|
||||
|
||||
this.hydrated = true;
|
||||
};
|
||||
|
||||
UnControlled.prototype.componentDidMount = function() {
|
||||
var _this = this;
|
||||
|
||||
if (SERVER_RENDERED) return;
|
||||
this.detached = this.props.detach === true;
|
||||
|
||||
if (this.props.defineMode) {
|
||||
if (this.props.defineMode.name && this.props.defineMode.fn) {
|
||||
cm.defineMode(this.props.defineMode.name, this.props.defineMode.fn);
|
||||
}
|
||||
}
|
||||
|
||||
this.editor = cm(this.ref, this.props.options);
|
||||
this.shared = new Shared(this.editor, this.props);
|
||||
this.editor.on('beforeChange', function(cm, data) {
|
||||
if (_this.props.onBeforeChange) {
|
||||
_this.props.onBeforeChange(_this.editor, data, _this.editor.getValue(), _this.onBeforeChangeCb);
|
||||
}
|
||||
});
|
||||
this.editor.on('change', function(cm, data) {
|
||||
if (!_this.mounted || !_this.props.onChange) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (_this.props.onBeforeChange) {
|
||||
if (_this.continueChange) {
|
||||
_this.props.onChange(_this.editor, data, _this.editor.getValue());
|
||||
}
|
||||
} else {
|
||||
_this.props.onChange(_this.editor, data, _this.editor.getValue());
|
||||
}
|
||||
});
|
||||
this.hydrate(this.props);
|
||||
this.shared.apply(this.props);
|
||||
this.applied = true;
|
||||
this.mounted = true;
|
||||
this.shared.wire(this.props);
|
||||
this.editor.getDoc().clearHistory();
|
||||
|
||||
if (this.props.editorDidMount) {
|
||||
this.props.editorDidMount(this.editor, this.editor.getValue(), this.initCb);
|
||||
}
|
||||
};
|
||||
|
||||
UnControlled.prototype.componentDidUpdate = function(prevProps) {
|
||||
if (this.detached && this.props.detach === false) {
|
||||
this.detached = false;
|
||||
|
||||
if (prevProps.editorDidAttach) {
|
||||
prevProps.editorDidAttach(this.editor);
|
||||
}
|
||||
}
|
||||
|
||||
if (!this.detached && this.props.detach === true) {
|
||||
this.detached = true;
|
||||
|
||||
if (prevProps.editorDidDetach) {
|
||||
prevProps.editorDidDetach(this.editor);
|
||||
}
|
||||
}
|
||||
|
||||
if (SERVER_RENDERED || this.detached) return;
|
||||
var preserved = {
|
||||
cursor: null
|
||||
};
|
||||
|
||||
if (this.props.value !== prevProps.value) {
|
||||
this.hydrated = false;
|
||||
this.applied = false;
|
||||
this.appliedUserDefined = false;
|
||||
}
|
||||
|
||||
if (!prevProps.autoCursor && prevProps.autoCursor !== undefined) {
|
||||
preserved.cursor = this.editor.getDoc().getCursor();
|
||||
}
|
||||
|
||||
this.hydrate(this.props);
|
||||
|
||||
if (!this.applied) {
|
||||
this.shared.apply(prevProps);
|
||||
this.applied = true;
|
||||
}
|
||||
|
||||
if (!this.appliedUserDefined) {
|
||||
this.shared.applyUserDefined(prevProps, preserved);
|
||||
this.appliedUserDefined = true;
|
||||
}
|
||||
};
|
||||
|
||||
UnControlled.prototype.componentWillUnmount = function() {
|
||||
if (SERVER_RENDERED) return;
|
||||
|
||||
if (this.props.editorWillUnmount) {
|
||||
this.props.editorWillUnmount(cm);
|
||||
}
|
||||
};
|
||||
|
||||
UnControlled.prototype.shouldComponentUpdate = function(nextProps, nextState) {
|
||||
var update = true;
|
||||
if (SERVER_RENDERED) update = false;
|
||||
if (this.detached && nextProps.detach) update = false;
|
||||
return update;
|
||||
};
|
||||
|
||||
UnControlled.prototype.render = function() {
|
||||
var _this = this;
|
||||
|
||||
if (SERVER_RENDERED) return null;
|
||||
var className = this.props.className ? 'react-codemirror2 ' + this.props.className : 'react-codemirror2';
|
||||
return react.createElement('div', {
|
||||
className: className,
|
||||
ref: function ref(self) {
|
||||
return _this.ref = self;
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
return UnControlled;
|
||||
}(react.Component);
|
||||
|
||||
exports.UnControlled = UnControlled;
|
||||
});
|
||||
|
||||
var Controlled = reactCodemirror2.Controlled;
|
||||
export { Controlled };
|
||||
356
docs/_snowpack/pkg/react-dom.js
vendored
356
docs/_snowpack/pkg/react-dom.js
vendored
@ -1,356 +0,0 @@
|
||||
import { c as createCommonjsModule } from './common/_commonjsHelpers-8c19dec8.js';
|
||||
import { r as react } from './common/index-67cfdec9.js';
|
||||
import { o as objectAssign } from './common/index-d01087d6.js';
|
||||
|
||||
var scheduler_production_min = createCommonjsModule(function (module, exports) {
|
||||
var f,g,h,k;if("object"===typeof performance&&"function"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()};}else {var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q};}
|
||||
if("undefined"===typeof window||"function"!==typeof MessageChannel){var t=null,u=null,w=function(){if(null!==t)try{var a=exports.unstable_now();t(!0,a);t=null;}catch(b){throw setTimeout(w,0),b;}};f=function(a){null!==t?setTimeout(f,0,a):(t=a,setTimeout(w,0));};g=function(a,b){u=setTimeout(a,b);};h=function(){clearTimeout(u);};exports.unstable_shouldYield=function(){return !1};k=exports.unstable_forceFrameRate=function(){};}else {var x=window.setTimeout,y=window.clearTimeout;if("undefined"!==typeof console){var z=
|
||||
window.cancelAnimationFrame;"function"!==typeof window.requestAnimationFrame&&console.error("This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills");"function"!==typeof z&&console.error("This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills");}var A=!1,B=null,C=-1,D=5,E=0;exports.unstable_shouldYield=function(){return exports.unstable_now()>=
|
||||
E};k=function(){};exports.unstable_forceFrameRate=function(a){0>a||125<a?console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"):D=0<a?Math.floor(1E3/a):5;};var F=new MessageChannel,G=F.port2;F.port1.onmessage=function(){if(null!==B){var a=exports.unstable_now();E=a+D;try{B(!0,a)?G.postMessage(null):(A=!1,B=null);}catch(b){throw G.postMessage(null),b;}}else A=!1;};f=function(a){B=a;A||(A=!0,G.postMessage(null));};g=function(a,b){C=
|
||||
x(function(){a(exports.unstable_now());},b);};h=function(){y(C);C=-1;};}function H(a,b){var c=a.length;a.push(b);a:for(;;){var d=c-1>>>1,e=a[d];if(void 0!==e&&0<I(e,b))a[d]=b,a[c]=e,c=d;else break a}}function J(a){a=a[0];return void 0===a?null:a}
|
||||
function K(a){var b=a[0];if(void 0!==b){var c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length;d<e;){var m=2*(d+1)-1,n=a[m],v=m+1,r=a[v];if(void 0!==n&&0>I(n,c))void 0!==r&&0>I(r,n)?(a[d]=r,a[v]=c,d=v):(a[d]=n,a[m]=c,d=m);else if(void 0!==r&&0>I(r,c))a[d]=r,a[v]=c,d=v;else break a}}return b}return null}function I(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}var L=[],M=[],N=1,O=null,P=3,Q=!1,R=!1,S=!1;
|
||||
function T(a){for(var b=J(M);null!==b;){if(null===b.callback)K(M);else if(b.startTime<=a)K(M),b.sortIndex=b.expirationTime,H(L,b);else break;b=J(M);}}function U(a){S=!1;T(a);if(!R)if(null!==J(L))R=!0,f(V);else {var b=J(M);null!==b&&g(U,b.startTime-a);}}
|
||||
function V(a,b){R=!1;S&&(S=!1,h());Q=!0;var c=P;try{T(b);for(O=J(L);null!==O&&(!(O.expirationTime>b)||a&&!exports.unstable_shouldYield());){var d=O.callback;if("function"===typeof d){O.callback=null;P=O.priorityLevel;var e=d(O.expirationTime<=b);b=exports.unstable_now();"function"===typeof e?O.callback=e:O===J(L)&&K(L);T(b);}else K(L);O=J(L);}if(null!==O)var m=!0;else {var n=J(M);null!==n&&g(U,n.startTime-b);m=!1;}return m}finally{O=null,P=c,Q=!1;}}var W=k;exports.unstable_IdlePriority=5;
|
||||
exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null;};exports.unstable_continueExecution=function(){R||Q||(R=!0,f(V));};exports.unstable_getCurrentPriorityLevel=function(){return P};exports.unstable_getFirstCallbackNode=function(){return J(L)};
|
||||
exports.unstable_next=function(a){switch(P){case 1:case 2:case 3:var b=3;break;default:b=P;}var c=P;P=b;try{return a()}finally{P=c;}};exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=W;exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3;}var c=P;P=a;try{return b()}finally{P=c;}};
|
||||
exports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();"object"===typeof c&&null!==c?(c=c.delay,c="number"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3;}e=c+e;a={id:N++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,H(M,a),null===J(L)&&a===J(M)&&(S?h():S=!0,g(U,c-d))):(a.sortIndex=e,H(L,a),R||Q||(R=!0,f(V)));return a};
|
||||
exports.unstable_wrapCallback=function(a){var b=P;return function(){var c=P;P=b;try{return a.apply(this,arguments)}finally{P=c;}}};
|
||||
});
|
||||
|
||||
var scheduler = createCommonjsModule(function (module) {
|
||||
|
||||
{
|
||||
module.exports = scheduler_production_min;
|
||||
}
|
||||
});
|
||||
|
||||
function y(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return "Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}if(!react)throw Error(y(227));var ba=new Set,ca={};function da(a,b){ea(a,b);ea(a+"Capture",b);}
|
||||
function ea(a,b){ca[a]=b;for(a=0;a<b.length;a++)ba.add(b[a]);}
|
||||
var fa=!("undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement),ha=/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,ia=Object.prototype.hasOwnProperty,
|
||||
ja={},ka={};function la(a){if(ia.call(ka,a))return !0;if(ia.call(ja,a))return !1;if(ha.test(a))return ka[a]=!0;ja[a]=!0;return !1}function ma(a,b,c,d){if(null!==c&&0===c.type)return !1;switch(typeof b){case "function":case "symbol":return !0;case "boolean":if(d)return !1;if(null!==c)return !c.acceptsBooleans;a=a.toLowerCase().slice(0,5);return "data-"!==a&&"aria-"!==a;default:return !1}}
|
||||
function na(a,b,c,d){if(null===b||"undefined"===typeof b||ma(a,b,c,d))return !0;if(d)return !1;if(null!==c)switch(c.type){case 3:return !b;case 4:return !1===b;case 5:return isNaN(b);case 6:return isNaN(b)||1>b}return !1}function B(a,b,c,d,e,f,g){this.acceptsBooleans=2===b||3===b||4===b;this.attributeName=d;this.attributeNamespace=e;this.mustUseProperty=c;this.propertyName=a;this.type=b;this.sanitizeURL=f;this.removeEmptyString=g;}var D={};
|
||||
"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a){D[a]=new B(a,0,!1,a,null,!1,!1);});[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(a){var b=a[0];D[b]=new B(b,1,!1,a[1],null,!1,!1);});["contentEditable","draggable","spellCheck","value"].forEach(function(a){D[a]=new B(a,2,!1,a.toLowerCase(),null,!1,!1);});
|
||||
["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(a){D[a]=new B(a,2,!1,a,null,!1,!1);});"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a){D[a]=new B(a,3,!1,a.toLowerCase(),null,!1,!1);});
|
||||
["checked","multiple","muted","selected"].forEach(function(a){D[a]=new B(a,3,!0,a,null,!1,!1);});["capture","download"].forEach(function(a){D[a]=new B(a,4,!1,a,null,!1,!1);});["cols","rows","size","span"].forEach(function(a){D[a]=new B(a,6,!1,a,null,!1,!1);});["rowSpan","start"].forEach(function(a){D[a]=new B(a,5,!1,a.toLowerCase(),null,!1,!1);});var oa=/[\-:]([a-z])/g;function pa(a){return a[1].toUpperCase()}
|
||||
"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a){var b=a.replace(oa,
|
||||
pa);D[b]=new B(b,1,!1,a,null,!1,!1);});"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a){var b=a.replace(oa,pa);D[b]=new B(b,1,!1,a,"http://www.w3.org/1999/xlink",!1,!1);});["xml:base","xml:lang","xml:space"].forEach(function(a){var b=a.replace(oa,pa);D[b]=new B(b,1,!1,a,"http://www.w3.org/XML/1998/namespace",!1,!1);});["tabIndex","crossOrigin"].forEach(function(a){D[a]=new B(a,1,!1,a.toLowerCase(),null,!1,!1);});
|
||||
D.xlinkHref=new B("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1);["src","href","action","formAction"].forEach(function(a){D[a]=new B(a,1,!1,a.toLowerCase(),null,!0,!0);});
|
||||
function qa(a,b,c,d){var e=D.hasOwnProperty(b)?D[b]:null;var f=null!==e?0===e.type:d?!1:!(2<b.length)||"o"!==b[0]&&"O"!==b[0]||"n"!==b[1]&&"N"!==b[1]?!1:!0;f||(na(b,c,e,d)&&(c=null),d||null===e?la(b)&&(null===c?a.removeAttribute(b):a.setAttribute(b,""+c)):e.mustUseProperty?a[e.propertyName]=null===c?3===e.type?!1:"":c:(b=e.attributeName,d=e.attributeNamespace,null===c?a.removeAttribute(b):(e=e.type,c=3===e||4===e&&!0===c?"":""+c,d?a.setAttributeNS(d,b,c):a.setAttribute(b,c))));}
|
||||
var ra=react.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,sa=60103,ta=60106,ua=60107,wa=60108,xa=60114,ya=60109,za=60110,Aa=60112,Ba=60113,Ca=60120,Da=60115,Ea=60116,Fa=60121,Ga=60128,Ha=60129,Ia=60130,Ja=60131;
|
||||
if("function"===typeof Symbol&&Symbol.for){var E=Symbol.for;sa=E("react.element");ta=E("react.portal");ua=E("react.fragment");wa=E("react.strict_mode");xa=E("react.profiler");ya=E("react.provider");za=E("react.context");Aa=E("react.forward_ref");Ba=E("react.suspense");Ca=E("react.suspense_list");Da=E("react.memo");Ea=E("react.lazy");Fa=E("react.block");E("react.scope");Ga=E("react.opaque.id");Ha=E("react.debug_trace_mode");Ia=E("react.offscreen");Ja=E("react.legacy_hidden");}
|
||||
var Ka="function"===typeof Symbol&&Symbol.iterator;function La(a){if(null===a||"object"!==typeof a)return null;a=Ka&&a[Ka]||a["@@iterator"];return "function"===typeof a?a:null}var Ma;function Na(a){if(void 0===Ma)try{throw Error();}catch(c){var b=c.stack.trim().match(/\n( *(at )?)/);Ma=b&&b[1]||"";}return "\n"+Ma+a}var Oa=!1;
|
||||
function Pa(a,b){if(!a||Oa)return "";Oa=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{if(b)if(b=function(){throw Error();},Object.defineProperty(b.prototype,"props",{set:function(){throw Error();}}),"object"===typeof Reflect&&Reflect.construct){try{Reflect.construct(b,[]);}catch(k){var d=k;}Reflect.construct(a,[],b);}else {try{b.call();}catch(k){d=k;}a.call(b.prototype);}else {try{throw Error();}catch(k){d=k;}a();}}catch(k){if(k&&d&&"string"===typeof k.stack){for(var e=k.stack.split("\n"),
|
||||
f=d.stack.split("\n"),g=e.length-1,h=f.length-1;1<=g&&0<=h&&e[g]!==f[h];)h--;for(;1<=g&&0<=h;g--,h--)if(e[g]!==f[h]){if(1!==g||1!==h){do if(g--,h--,0>h||e[g]!==f[h])return "\n"+e[g].replace(" at new "," at ");while(1<=g&&0<=h)}break}}}finally{Oa=!1,Error.prepareStackTrace=c;}return (a=a?a.displayName||a.name:"")?Na(a):""}
|
||||
function Qa(a){switch(a.tag){case 5:return Na(a.type);case 16:return Na("Lazy");case 13:return Na("Suspense");case 19:return Na("SuspenseList");case 0:case 2:case 15:return a=Pa(a.type,!1),a;case 11:return a=Pa(a.type.render,!1),a;case 22:return a=Pa(a.type._render,!1),a;case 1:return a=Pa(a.type,!0),a;default:return ""}}
|
||||
function Ra(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case ua:return "Fragment";case ta:return "Portal";case xa:return "Profiler";case wa:return "StrictMode";case Ba:return "Suspense";case Ca:return "SuspenseList"}if("object"===typeof a)switch(a.$$typeof){case za:return (a.displayName||"Context")+".Consumer";case ya:return (a._context.displayName||"Context")+".Provider";case Aa:var b=a.render;b=b.displayName||b.name||"";
|
||||
return a.displayName||(""!==b?"ForwardRef("+b+")":"ForwardRef");case Da:return Ra(a.type);case Fa:return Ra(a._render);case Ea:b=a._payload;a=a._init;try{return Ra(a(b))}catch(c){}}return null}function Sa(a){switch(typeof a){case "boolean":case "number":case "object":case "string":case "undefined":return a;default:return ""}}function Ta(a){var b=a.type;return (a=a.nodeName)&&"input"===a.toLowerCase()&&("checkbox"===b||"radio"===b)}
|
||||
function Ua(a){var b=Ta(a)?"checked":"value",c=Object.getOwnPropertyDescriptor(a.constructor.prototype,b),d=""+a[b];if(!a.hasOwnProperty(b)&&"undefined"!==typeof c&&"function"===typeof c.get&&"function"===typeof c.set){var e=c.get,f=c.set;Object.defineProperty(a,b,{configurable:!0,get:function(){return e.call(this)},set:function(a){d=""+a;f.call(this,a);}});Object.defineProperty(a,b,{enumerable:c.enumerable});return {getValue:function(){return d},setValue:function(a){d=""+a;},stopTracking:function(){a._valueTracker=
|
||||
null;delete a[b];}}}}function Va(a){a._valueTracker||(a._valueTracker=Ua(a));}function Wa(a){if(!a)return !1;var b=a._valueTracker;if(!b)return !0;var c=b.getValue();var d="";a&&(d=Ta(a)?a.checked?"true":"false":a.value);a=d;return a!==c?(b.setValue(a),!0):!1}function Xa(a){a=a||("undefined"!==typeof document?document:void 0);if("undefined"===typeof a)return null;try{return a.activeElement||a.body}catch(b){return a.body}}
|
||||
function Ya(a,b){var c=b.checked;return objectAssign({},b,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:null!=c?c:a._wrapperState.initialChecked})}function Za(a,b){var c=null==b.defaultValue?"":b.defaultValue,d=null!=b.checked?b.checked:b.defaultChecked;c=Sa(null!=b.value?b.value:c);a._wrapperState={initialChecked:d,initialValue:c,controlled:"checkbox"===b.type||"radio"===b.type?null!=b.checked:null!=b.value};}function $a(a,b){b=b.checked;null!=b&&qa(a,"checked",b,!1);}
|
||||
function ab(a,b){$a(a,b);var c=Sa(b.value),d=b.type;if(null!=c)if("number"===d){if(0===c&&""===a.value||a.value!=c)a.value=""+c;}else a.value!==""+c&&(a.value=""+c);else if("submit"===d||"reset"===d){a.removeAttribute("value");return}b.hasOwnProperty("value")?bb(a,b.type,c):b.hasOwnProperty("defaultValue")&&bb(a,b.type,Sa(b.defaultValue));null==b.checked&&null!=b.defaultChecked&&(a.defaultChecked=!!b.defaultChecked);}
|
||||
function cb(a,b,c){if(b.hasOwnProperty("value")||b.hasOwnProperty("defaultValue")){var d=b.type;if(!("submit"!==d&&"reset"!==d||void 0!==b.value&&null!==b.value))return;b=""+a._wrapperState.initialValue;c||b===a.value||(a.value=b);a.defaultValue=b;}c=a.name;""!==c&&(a.name="");a.defaultChecked=!!a._wrapperState.initialChecked;""!==c&&(a.name=c);}
|
||||
function bb(a,b,c){if("number"!==b||Xa(a.ownerDocument)!==a)null==c?a.defaultValue=""+a._wrapperState.initialValue:a.defaultValue!==""+c&&(a.defaultValue=""+c);}function db(a){var b="";react.Children.forEach(a,function(a){null!=a&&(b+=a);});return b}function eb(a,b){a=objectAssign({children:void 0},b);if(b=db(b.children))a.children=b;return a}
|
||||
function fb(a,b,c,d){a=a.options;if(b){b={};for(var e=0;e<c.length;e++)b["$"+c[e]]=!0;for(c=0;c<a.length;c++)e=b.hasOwnProperty("$"+a[c].value),a[c].selected!==e&&(a[c].selected=e),e&&d&&(a[c].defaultSelected=!0);}else {c=""+Sa(c);b=null;for(e=0;e<a.length;e++){if(a[e].value===c){a[e].selected=!0;d&&(a[e].defaultSelected=!0);return}null!==b||a[e].disabled||(b=a[e]);}null!==b&&(b.selected=!0);}}
|
||||
function gb(a,b){if(null!=b.dangerouslySetInnerHTML)throw Error(y(91));return objectAssign({},b,{value:void 0,defaultValue:void 0,children:""+a._wrapperState.initialValue})}function hb(a,b){var c=b.value;if(null==c){c=b.children;b=b.defaultValue;if(null!=c){if(null!=b)throw Error(y(92));if(Array.isArray(c)){if(!(1>=c.length))throw Error(y(93));c=c[0];}b=c;}null==b&&(b="");c=b;}a._wrapperState={initialValue:Sa(c)};}
|
||||
function ib(a,b){var c=Sa(b.value),d=Sa(b.defaultValue);null!=c&&(c=""+c,c!==a.value&&(a.value=c),null==b.defaultValue&&a.defaultValue!==c&&(a.defaultValue=c));null!=d&&(a.defaultValue=""+d);}function jb(a){var b=a.textContent;b===a._wrapperState.initialValue&&""!==b&&null!==b&&(a.value=b);}var kb={html:"http://www.w3.org/1999/xhtml",mathml:"http://www.w3.org/1998/Math/MathML",svg:"http://www.w3.org/2000/svg"};
|
||||
function lb(a){switch(a){case "svg":return "http://www.w3.org/2000/svg";case "math":return "http://www.w3.org/1998/Math/MathML";default:return "http://www.w3.org/1999/xhtml"}}function mb(a,b){return null==a||"http://www.w3.org/1999/xhtml"===a?lb(b):"http://www.w3.org/2000/svg"===a&&"foreignObject"===b?"http://www.w3.org/1999/xhtml":a}
|
||||
var nb,ob=function(a){return "undefined"!==typeof MSApp&&MSApp.execUnsafeLocalFunction?function(b,c,d,e){MSApp.execUnsafeLocalFunction(function(){return a(b,c,d,e)});}:a}(function(a,b){if(a.namespaceURI!==kb.svg||"innerHTML"in a)a.innerHTML=b;else {nb=nb||document.createElement("div");nb.innerHTML="<svg>"+b.valueOf().toString()+"</svg>";for(b=nb.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;b.firstChild;)a.appendChild(b.firstChild);}});
|
||||
function pb(a,b){if(b){var c=a.firstChild;if(c&&c===a.lastChild&&3===c.nodeType){c.nodeValue=b;return}}a.textContent=b;}
|
||||
var qb={animationIterationCount:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,
|
||||
floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},rb=["Webkit","ms","Moz","O"];Object.keys(qb).forEach(function(a){rb.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);qb[b]=qb[a];});});function sb(a,b,c){return null==b||"boolean"===typeof b||""===b?"":c||"number"!==typeof b||0===b||qb.hasOwnProperty(a)&&qb[a]?(""+b).trim():b+"px"}
|
||||
function tb(a,b){a=a.style;for(var c in b)if(b.hasOwnProperty(c)){var d=0===c.indexOf("--"),e=sb(c,b[c],d);"float"===c&&(c="cssFloat");d?a.setProperty(c,e):a[c]=e;}}var ub=objectAssign({menuitem:!0},{area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0});
|
||||
function vb(a,b){if(b){if(ub[a]&&(null!=b.children||null!=b.dangerouslySetInnerHTML))throw Error(y(137,a));if(null!=b.dangerouslySetInnerHTML){if(null!=b.children)throw Error(y(60));if(!("object"===typeof b.dangerouslySetInnerHTML&&"__html"in b.dangerouslySetInnerHTML))throw Error(y(61));}if(null!=b.style&&"object"!==typeof b.style)throw Error(y(62));}}
|
||||
function wb(a,b){if(-1===a.indexOf("-"))return "string"===typeof b.is;switch(a){case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":return !1;default:return !0}}function xb(a){a=a.target||a.srcElement||window;a.correspondingUseElement&&(a=a.correspondingUseElement);return 3===a.nodeType?a.parentNode:a}var yb=null,zb=null,Ab=null;
|
||||
function Bb(a){if(a=Cb(a)){if("function"!==typeof yb)throw Error(y(280));var b=a.stateNode;b&&(b=Db(b),yb(a.stateNode,a.type,b));}}function Eb(a){zb?Ab?Ab.push(a):Ab=[a]:zb=a;}function Fb(){if(zb){var a=zb,b=Ab;Ab=zb=null;Bb(a);if(b)for(a=0;a<b.length;a++)Bb(b[a]);}}function Gb(a,b){return a(b)}function Hb(a,b,c,d,e){return a(b,c,d,e)}function Ib(){}var Jb=Gb,Kb=!1,Lb=!1;function Mb(){if(null!==zb||null!==Ab)Ib(),Fb();}
|
||||
function Nb(a,b,c){if(Lb)return a(b,c);Lb=!0;try{return Jb(a,b,c)}finally{Lb=!1,Mb();}}
|
||||
function Ob(a,b){var c=a.stateNode;if(null===c)return null;var d=Db(c);if(null===d)return null;c=d[b];a:switch(b){case "onClick":case "onClickCapture":case "onDoubleClick":case "onDoubleClickCapture":case "onMouseDown":case "onMouseDownCapture":case "onMouseMove":case "onMouseMoveCapture":case "onMouseUp":case "onMouseUpCapture":case "onMouseEnter":(d=!d.disabled)||(a=a.type,d=!("button"===a||"input"===a||"select"===a||"textarea"===a));a=!d;break a;default:a=!1;}if(a)return null;if(c&&"function"!==
|
||||
typeof c)throw Error(y(231,b,typeof c));return c}var Pb=!1;if(fa)try{var Qb={};Object.defineProperty(Qb,"passive",{get:function(){Pb=!0;}});window.addEventListener("test",Qb,Qb);window.removeEventListener("test",Qb,Qb);}catch(a){Pb=!1;}function Rb(a,b,c,d,e,f,g,h,k){var l=Array.prototype.slice.call(arguments,3);try{b.apply(c,l);}catch(n){this.onError(n);}}var Sb=!1,Tb=null,Ub=!1,Vb=null,Wb={onError:function(a){Sb=!0;Tb=a;}};function Xb(a,b,c,d,e,f,g,h,k){Sb=!1;Tb=null;Rb.apply(Wb,arguments);}
|
||||
function Yb(a,b,c,d,e,f,g,h,k){Xb.apply(this,arguments);if(Sb){if(Sb){var l=Tb;Sb=!1;Tb=null;}else throw Error(y(198));Ub||(Ub=!0,Vb=l);}}function Zb(a){var b=a,c=a;if(a.alternate)for(;b.return;)b=b.return;else {a=b;do b=a,0!==(b.flags&1026)&&(c=b.return),a=b.return;while(a)}return 3===b.tag?c:null}function $b(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function ac(a){if(Zb(a)!==a)throw Error(y(188));}
|
||||
function bc(a){var b=a.alternate;if(!b){b=Zb(a);if(null===b)throw Error(y(188));return b!==a?null:a}for(var c=a,d=b;;){var e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d){c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return ac(e),a;if(f===d)return ac(e),b;f=f.sibling;}throw Error(y(188));}if(c.return!==d.return)c=e,d=f;else {for(var g=!1,h=e.child;h;){if(h===c){g=!0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling;}if(!g){for(h=f.child;h;){if(h===
|
||||
c){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling;}if(!g)throw Error(y(189));}}if(c.alternate!==d)throw Error(y(190));}if(3!==c.tag)throw Error(y(188));return c.stateNode.current===c?a:b}function cc(a){a=bc(a);if(!a)return null;for(var b=a;;){if(5===b.tag||6===b.tag)return b;if(b.child)b.child.return=b,b=b.child;else {if(b===a)break;for(;!b.sibling;){if(!b.return||b.return===a)return null;b=b.return;}b.sibling.return=b.return;b=b.sibling;}}return null}
|
||||
function dc(a,b){for(var c=a.alternate;null!==b;){if(b===a||b===c)return !0;b=b.return;}return !1}var ec,fc,gc,hc,ic=!1,jc=[],kc=null,lc=null,mc=null,nc=new Map,oc=new Map,pc=[],qc="mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(" ");
|
||||
function rc(a,b,c,d,e){return {blockedOn:a,domEventName:b,eventSystemFlags:c|16,nativeEvent:e,targetContainers:[d]}}function sc(a,b){switch(a){case "focusin":case "focusout":kc=null;break;case "dragenter":case "dragleave":lc=null;break;case "mouseover":case "mouseout":mc=null;break;case "pointerover":case "pointerout":nc.delete(b.pointerId);break;case "gotpointercapture":case "lostpointercapture":oc.delete(b.pointerId);}}
|
||||
function tc(a,b,c,d,e,f){if(null===a||a.nativeEvent!==f)return a=rc(b,c,d,e,f),null!==b&&(b=Cb(b),null!==b&&fc(b)),a;a.eventSystemFlags|=d;b=a.targetContainers;null!==e&&-1===b.indexOf(e)&&b.push(e);return a}
|
||||
function uc(a,b,c,d,e){switch(b){case "focusin":return kc=tc(kc,a,b,c,d,e),!0;case "dragenter":return lc=tc(lc,a,b,c,d,e),!0;case "mouseover":return mc=tc(mc,a,b,c,d,e),!0;case "pointerover":var f=e.pointerId;nc.set(f,tc(nc.get(f)||null,a,b,c,d,e));return !0;case "gotpointercapture":return f=e.pointerId,oc.set(f,tc(oc.get(f)||null,a,b,c,d,e)),!0}return !1}
|
||||
function vc(a){var b=wc(a.target);if(null!==b){var c=Zb(b);if(null!==c)if(b=c.tag,13===b){if(b=$b(c),null!==b){a.blockedOn=b;hc(a.lanePriority,function(){scheduler.unstable_runWithPriority(a.priority,function(){gc(c);});});return}}else if(3===b&&c.stateNode.hydrate){a.blockedOn=3===c.tag?c.stateNode.containerInfo:null;return}}a.blockedOn=null;}
|
||||
function xc(a){if(null!==a.blockedOn)return !1;for(var b=a.targetContainers;0<b.length;){var c=yc(a.domEventName,a.eventSystemFlags,b[0],a.nativeEvent);if(null!==c)return b=Cb(c),null!==b&&fc(b),a.blockedOn=c,!1;b.shift();}return !0}function zc(a,b,c){xc(a)&&c.delete(b);}
|
||||
function Ac(){for(ic=!1;0<jc.length;){var a=jc[0];if(null!==a.blockedOn){a=Cb(a.blockedOn);null!==a&&ec(a);break}for(var b=a.targetContainers;0<b.length;){var c=yc(a.domEventName,a.eventSystemFlags,b[0],a.nativeEvent);if(null!==c){a.blockedOn=c;break}b.shift();}null===a.blockedOn&&jc.shift();}null!==kc&&xc(kc)&&(kc=null);null!==lc&&xc(lc)&&(lc=null);null!==mc&&xc(mc)&&(mc=null);nc.forEach(zc);oc.forEach(zc);}
|
||||
function Bc(a,b){a.blockedOn===b&&(a.blockedOn=null,ic||(ic=!0,scheduler.unstable_scheduleCallback(scheduler.unstable_NormalPriority,Ac)));}
|
||||
function Cc(a){function b(b){return Bc(b,a)}if(0<jc.length){Bc(jc[0],a);for(var c=1;c<jc.length;c++){var d=jc[c];d.blockedOn===a&&(d.blockedOn=null);}}null!==kc&&Bc(kc,a);null!==lc&&Bc(lc,a);null!==mc&&Bc(mc,a);nc.forEach(b);oc.forEach(b);for(c=0;c<pc.length;c++)d=pc[c],d.blockedOn===a&&(d.blockedOn=null);for(;0<pc.length&&(c=pc[0],null===c.blockedOn);)vc(c),null===c.blockedOn&&pc.shift();}
|
||||
function Dc(a,b){var c={};c[a.toLowerCase()]=b.toLowerCase();c["Webkit"+a]="webkit"+b;c["Moz"+a]="moz"+b;return c}var Ec={animationend:Dc("Animation","AnimationEnd"),animationiteration:Dc("Animation","AnimationIteration"),animationstart:Dc("Animation","AnimationStart"),transitionend:Dc("Transition","TransitionEnd")},Fc={},Gc={};
|
||||
fa&&(Gc=document.createElement("div").style,"AnimationEvent"in window||(delete Ec.animationend.animation,delete Ec.animationiteration.animation,delete Ec.animationstart.animation),"TransitionEvent"in window||delete Ec.transitionend.transition);function Hc(a){if(Fc[a])return Fc[a];if(!Ec[a])return a;var b=Ec[a],c;for(c in b)if(b.hasOwnProperty(c)&&c in Gc)return Fc[a]=b[c];return a}
|
||||
var Ic=Hc("animationend"),Jc=Hc("animationiteration"),Kc=Hc("animationstart"),Lc=Hc("transitionend"),Mc=new Map,Nc=new Map,Oc=["abort","abort",Ic,"animationEnd",Jc,"animationIteration",Kc,"animationStart","canplay","canPlay","canplaythrough","canPlayThrough","durationchange","durationChange","emptied","emptied","encrypted","encrypted","ended","ended","error","error","gotpointercapture","gotPointerCapture","load","load","loadeddata","loadedData","loadedmetadata","loadedMetadata","loadstart","loadStart",
|
||||
"lostpointercapture","lostPointerCapture","playing","playing","progress","progress","seeking","seeking","stalled","stalled","suspend","suspend","timeupdate","timeUpdate",Lc,"transitionEnd","waiting","waiting"];function Pc(a,b){for(var c=0;c<a.length;c+=2){var d=a[c],e=a[c+1];e="on"+(e[0].toUpperCase()+e.slice(1));Nc.set(d,b);Mc.set(d,e);da(e,[d]);}}var Qc=scheduler.unstable_now;Qc();var F=8;
|
||||
function Rc(a){if(0!==(1&a))return F=15,1;if(0!==(2&a))return F=14,2;if(0!==(4&a))return F=13,4;var b=24&a;if(0!==b)return F=12,b;if(0!==(a&32))return F=11,32;b=192&a;if(0!==b)return F=10,b;if(0!==(a&256))return F=9,256;b=3584&a;if(0!==b)return F=8,b;if(0!==(a&4096))return F=7,4096;b=4186112&a;if(0!==b)return F=6,b;b=62914560&a;if(0!==b)return F=5,b;if(a&67108864)return F=4,67108864;if(0!==(a&134217728))return F=3,134217728;b=805306368&a;if(0!==b)return F=2,b;if(0!==(1073741824&a))return F=1,1073741824;
|
||||
F=8;return a}function Sc(a){switch(a){case 99:return 15;case 98:return 10;case 97:case 96:return 8;case 95:return 2;default:return 0}}function Tc(a){switch(a){case 15:case 14:return 99;case 13:case 12:case 11:case 10:return 98;case 9:case 8:case 7:case 6:case 4:case 5:return 97;case 3:case 2:case 1:return 95;case 0:return 90;default:throw Error(y(358,a));}}
|
||||
function Uc(a,b){var c=a.pendingLanes;if(0===c)return F=0;var d=0,e=0,f=a.expiredLanes,g=a.suspendedLanes,h=a.pingedLanes;if(0!==f)d=f,e=F=15;else if(f=c&134217727,0!==f){var k=f&~g;0!==k?(d=Rc(k),e=F):(h&=f,0!==h&&(d=Rc(h),e=F));}else f=c&~g,0!==f?(d=Rc(f),e=F):0!==h&&(d=Rc(h),e=F);if(0===d)return 0;d=31-Vc(d);d=c&((0>d?0:1<<d)<<1)-1;if(0!==b&&b!==d&&0===(b&g)){Rc(b);if(e<=F)return b;F=e;}b=a.entangledLanes;if(0!==b)for(a=a.entanglements,b&=d;0<b;)c=31-Vc(b),e=1<<c,d|=a[c],b&=~e;return d}
|
||||
function Wc(a){a=a.pendingLanes&-1073741825;return 0!==a?a:a&1073741824?1073741824:0}function Xc(a,b){switch(a){case 15:return 1;case 14:return 2;case 12:return a=Yc(24&~b),0===a?Xc(10,b):a;case 10:return a=Yc(192&~b),0===a?Xc(8,b):a;case 8:return a=Yc(3584&~b),0===a&&(a=Yc(4186112&~b),0===a&&(a=512)),a;case 2:return b=Yc(805306368&~b),0===b&&(b=268435456),b}throw Error(y(358,a));}function Yc(a){return a&-a}function Zc(a){for(var b=[],c=0;31>c;c++)b.push(a);return b}
|
||||
function $c(a,b,c){a.pendingLanes|=b;var d=b-1;a.suspendedLanes&=d;a.pingedLanes&=d;a=a.eventTimes;b=31-Vc(b);a[b]=c;}var Vc=Math.clz32?Math.clz32:ad,bd=Math.log,cd=Math.LN2;function ad(a){return 0===a?32:31-(bd(a)/cd|0)|0}var dd=scheduler.unstable_UserBlockingPriority,ed=scheduler.unstable_runWithPriority,fd=!0;function gd(a,b,c,d){Kb||Ib();var e=hd,f=Kb;Kb=!0;try{Hb(e,a,b,c,d);}finally{(Kb=f)||Mb();}}function id(a,b,c,d){ed(dd,hd.bind(null,a,b,c,d));}
|
||||
function hd(a,b,c,d){if(fd){var e;if((e=0===(b&4))&&0<jc.length&&-1<qc.indexOf(a))a=rc(null,a,b,c,d),jc.push(a);else {var f=yc(a,b,c,d);if(null===f)e&&sc(a,d);else {if(e){if(-1<qc.indexOf(a)){a=rc(f,a,b,c,d);jc.push(a);return}if(uc(f,a,b,c,d))return;sc(a,d);}jd(a,b,d,null,c);}}}}
|
||||
function yc(a,b,c,d){var e=xb(d);e=wc(e);if(null!==e){var f=Zb(e);if(null===f)e=null;else {var g=f.tag;if(13===g){e=$b(f);if(null!==e)return e;e=null;}else if(3===g){if(f.stateNode.hydrate)return 3===f.tag?f.stateNode.containerInfo:null;e=null;}else f!==e&&(e=null);}}jd(a,b,d,e,c);return null}var kd=null,ld=null,md=null;
|
||||
function nd(){if(md)return md;var a,b=ld,c=b.length,d,e="value"in kd?kd.value:kd.textContent,f=e.length;for(a=0;a<c&&b[a]===e[a];a++);var g=c-a;for(d=1;d<=g&&b[c-d]===e[f-d];d++);return md=e.slice(a,1<d?1-d:void 0)}function od(a){var b=a.keyCode;"charCode"in a?(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?a:0}function pd(){return !0}function qd(){return !1}
|
||||
function rd(a){function b(b,d,e,f,g){this._reactName=b;this._targetInst=e;this.type=d;this.nativeEvent=f;this.target=g;this.currentTarget=null;for(var c in a)a.hasOwnProperty(c)&&(b=a[c],this[c]=b?b(f):f[c]);this.isDefaultPrevented=(null!=f.defaultPrevented?f.defaultPrevented:!1===f.returnValue)?pd:qd;this.isPropagationStopped=qd;return this}objectAssign(b.prototype,{preventDefault:function(){this.defaultPrevented=!0;var a=this.nativeEvent;a&&(a.preventDefault?a.preventDefault():"unknown"!==typeof a.returnValue&&
|
||||
(a.returnValue=!1),this.isDefaultPrevented=pd);},stopPropagation:function(){var a=this.nativeEvent;a&&(a.stopPropagation?a.stopPropagation():"unknown"!==typeof a.cancelBubble&&(a.cancelBubble=!0),this.isPropagationStopped=pd);},persist:function(){},isPersistent:pd});return b}
|
||||
var sd={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(a){return a.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},td=rd(sd),ud=objectAssign({},sd,{view:0,detail:0}),vd=rd(ud),wd,xd,yd,Ad=objectAssign({},ud,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:zd,button:0,buttons:0,relatedTarget:function(a){return void 0===a.relatedTarget?a.fromElement===a.srcElement?a.toElement:a.fromElement:a.relatedTarget},movementX:function(a){if("movementX"in
|
||||
a)return a.movementX;a!==yd&&(yd&&"mousemove"===a.type?(wd=a.screenX-yd.screenX,xd=a.screenY-yd.screenY):xd=wd=0,yd=a);return wd},movementY:function(a){return "movementY"in a?a.movementY:xd}}),Bd=rd(Ad),Cd=objectAssign({},Ad,{dataTransfer:0}),Dd=rd(Cd),Ed=objectAssign({},ud,{relatedTarget:0}),Fd=rd(Ed),Gd=objectAssign({},sd,{animationName:0,elapsedTime:0,pseudoElement:0}),Hd=rd(Gd),Id=objectAssign({},sd,{clipboardData:function(a){return "clipboardData"in a?a.clipboardData:window.clipboardData}}),Jd=rd(Id),Kd=objectAssign({},sd,{data:0}),Ld=rd(Kd),Md={Esc:"Escape",
|
||||
Spacebar:" ",Left:"ArrowLeft",Up:"ArrowUp",Right:"ArrowRight",Down:"ArrowDown",Del:"Delete",Win:"OS",Menu:"ContextMenu",Apps:"ContextMenu",Scroll:"ScrollLock",MozPrintableKey:"Unidentified"},Nd={8:"Backspace",9:"Tab",12:"Clear",13:"Enter",16:"Shift",17:"Control",18:"Alt",19:"Pause",20:"CapsLock",27:"Escape",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",45:"Insert",46:"Delete",112:"F1",113:"F2",114:"F3",115:"F4",116:"F5",117:"F6",118:"F7",
|
||||
119:"F8",120:"F9",121:"F10",122:"F11",123:"F12",144:"NumLock",145:"ScrollLock",224:"Meta"},Od={Alt:"altKey",Control:"ctrlKey",Meta:"metaKey",Shift:"shiftKey"};function Pd(a){var b=this.nativeEvent;return b.getModifierState?b.getModifierState(a):(a=Od[a])?!!b[a]:!1}function zd(){return Pd}
|
||||
var Qd=objectAssign({},ud,{key:function(a){if(a.key){var b=Md[a.key]||a.key;if("Unidentified"!==b)return b}return "keypress"===a.type?(a=od(a),13===a?"Enter":String.fromCharCode(a)):"keydown"===a.type||"keyup"===a.type?Nd[a.keyCode]||"Unidentified":""},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:zd,charCode:function(a){return "keypress"===a.type?od(a):0},keyCode:function(a){return "keydown"===a.type||"keyup"===a.type?a.keyCode:0},which:function(a){return "keypress"===
|
||||
a.type?od(a):"keydown"===a.type||"keyup"===a.type?a.keyCode:0}}),Rd=rd(Qd),Sd=objectAssign({},Ad,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),Td=rd(Sd),Ud=objectAssign({},ud,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:zd}),Vd=rd(Ud),Wd=objectAssign({},sd,{propertyName:0,elapsedTime:0,pseudoElement:0}),Xd=rd(Wd),Yd=objectAssign({},Ad,{deltaX:function(a){return "deltaX"in a?a.deltaX:"wheelDeltaX"in a?-a.wheelDeltaX:0},
|
||||
deltaY:function(a){return "deltaY"in a?a.deltaY:"wheelDeltaY"in a?-a.wheelDeltaY:"wheelDelta"in a?-a.wheelDelta:0},deltaZ:0,deltaMode:0}),Zd=rd(Yd),$d=[9,13,27,32],ae=fa&&"CompositionEvent"in window,be=null;fa&&"documentMode"in document&&(be=document.documentMode);var ce=fa&&"TextEvent"in window&&!be,de=fa&&(!ae||be&&8<be&&11>=be),ee=String.fromCharCode(32),fe=!1;
|
||||
function ge(a,b){switch(a){case "keyup":return -1!==$d.indexOf(b.keyCode);case "keydown":return 229!==b.keyCode;case "keypress":case "mousedown":case "focusout":return !0;default:return !1}}function he(a){a=a.detail;return "object"===typeof a&&"data"in a?a.data:null}var ie=!1;function je(a,b){switch(a){case "compositionend":return he(b);case "keypress":if(32!==b.which)return null;fe=!0;return ee;case "textInput":return a=b.data,a===ee&&fe?null:a;default:return null}}
|
||||
function ke(a,b){if(ie)return "compositionend"===a||!ae&&ge(a,b)?(a=nd(),md=ld=kd=null,ie=!1,a):null;switch(a){case "paste":return null;case "keypress":if(!(b.ctrlKey||b.altKey||b.metaKey)||b.ctrlKey&&b.altKey){if(b.char&&1<b.char.length)return b.char;if(b.which)return String.fromCharCode(b.which)}return null;case "compositionend":return de&&"ko"!==b.locale?null:b.data;default:return null}}
|
||||
var le={color:!0,date:!0,datetime:!0,"datetime-local":!0,email:!0,month:!0,number:!0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};function me(a){var b=a&&a.nodeName&&a.nodeName.toLowerCase();return "input"===b?!!le[a.type]:"textarea"===b?!0:!1}function ne(a,b,c,d){Eb(d);b=oe(b,"onChange");0<b.length&&(c=new td("onChange","change",null,c,d),a.push({event:c,listeners:b}));}var pe=null,qe=null;function re(a){se(a,0);}function te(a){var b=ue(a);if(Wa(b))return a}
|
||||
function ve(a,b){if("change"===a)return b}var we=!1;if(fa){var xe;if(fa){var ye="oninput"in document;if(!ye){var ze=document.createElement("div");ze.setAttribute("oninput","return;");ye="function"===typeof ze.oninput;}xe=ye;}else xe=!1;we=xe&&(!document.documentMode||9<document.documentMode);}function Ae(){pe&&(pe.detachEvent("onpropertychange",Be),qe=pe=null);}function Be(a){if("value"===a.propertyName&&te(qe)){var b=[];ne(b,qe,a,xb(a));a=re;if(Kb)a(b);else {Kb=!0;try{Gb(a,b);}finally{Kb=!1,Mb();}}}}
|
||||
function Ce(a,b,c){"focusin"===a?(Ae(),pe=b,qe=c,pe.attachEvent("onpropertychange",Be)):"focusout"===a&&Ae();}function De(a){if("selectionchange"===a||"keyup"===a||"keydown"===a)return te(qe)}function Ee(a,b){if("click"===a)return te(b)}function Fe(a,b){if("input"===a||"change"===a)return te(b)}function Ge(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var He="function"===typeof Object.is?Object.is:Ge,Ie=Object.prototype.hasOwnProperty;
|
||||
function Je(a,b){if(He(a,b))return !0;if("object"!==typeof a||null===a||"object"!==typeof b||null===b)return !1;var c=Object.keys(a),d=Object.keys(b);if(c.length!==d.length)return !1;for(d=0;d<c.length;d++)if(!Ie.call(b,c[d])||!He(a[c[d]],b[c[d]]))return !1;return !0}function Ke(a){for(;a&&a.firstChild;)a=a.firstChild;return a}
|
||||
function Le(a,b){var c=Ke(a);a=0;for(var d;c;){if(3===c.nodeType){d=a+c.textContent.length;if(a<=b&&d>=b)return {node:c,offset:b-a};a=d;}a:{for(;c;){if(c.nextSibling){c=c.nextSibling;break a}c=c.parentNode;}c=void 0;}c=Ke(c);}}function Me(a,b){return a&&b?a===b?!0:a&&3===a.nodeType?!1:b&&3===b.nodeType?Me(a,b.parentNode):"contains"in a?a.contains(b):a.compareDocumentPosition?!!(a.compareDocumentPosition(b)&16):!1:!1}
|
||||
function Ne(){for(var a=window,b=Xa();b instanceof a.HTMLIFrameElement;){try{var c="string"===typeof b.contentWindow.location.href;}catch(d){c=!1;}if(c)a=b.contentWindow;else break;b=Xa(a.document);}return b}function Oe(a){var b=a&&a.nodeName&&a.nodeName.toLowerCase();return b&&("input"===b&&("text"===a.type||"search"===a.type||"tel"===a.type||"url"===a.type||"password"===a.type)||"textarea"===b||"true"===a.contentEditable)}
|
||||
var Pe=fa&&"documentMode"in document&&11>=document.documentMode,Qe=null,Re=null,Se=null,Te=!1;
|
||||
function Ue(a,b,c){var d=c.window===c?c.document:9===c.nodeType?c:c.ownerDocument;Te||null==Qe||Qe!==Xa(d)||(d=Qe,"selectionStart"in d&&Oe(d)?d={start:d.selectionStart,end:d.selectionEnd}:(d=(d.ownerDocument&&d.ownerDocument.defaultView||window).getSelection(),d={anchorNode:d.anchorNode,anchorOffset:d.anchorOffset,focusNode:d.focusNode,focusOffset:d.focusOffset}),Se&&Je(Se,d)||(Se=d,d=oe(Re,"onSelect"),0<d.length&&(b=new td("onSelect","select",null,b,c),a.push({event:b,listeners:d}),b.target=Qe)));}
|
||||
Pc("cancel cancel click click close close contextmenu contextMenu copy copy cut cut auxclick auxClick dblclick doubleClick dragend dragEnd dragstart dragStart drop drop focusin focus focusout blur input input invalid invalid keydown keyDown keypress keyPress keyup keyUp mousedown mouseDown mouseup mouseUp paste paste pause pause play play pointercancel pointerCancel pointerdown pointerDown pointerup pointerUp ratechange rateChange reset reset seeked seeked submit submit touchcancel touchCancel touchend touchEnd touchstart touchStart volumechange volumeChange".split(" "),
|
||||
0);Pc("drag drag dragenter dragEnter dragexit dragExit dragleave dragLeave dragover dragOver mousemove mouseMove mouseout mouseOut mouseover mouseOver pointermove pointerMove pointerout pointerOut pointerover pointerOver scroll scroll toggle toggle touchmove touchMove wheel wheel".split(" "),1);Pc(Oc,2);for(var Ve="change selectionchange textInput compositionstart compositionend compositionupdate".split(" "),We=0;We<Ve.length;We++)Nc.set(Ve[We],0);ea("onMouseEnter",["mouseout","mouseover"]);
|
||||
ea("onMouseLeave",["mouseout","mouseover"]);ea("onPointerEnter",["pointerout","pointerover"]);ea("onPointerLeave",["pointerout","pointerover"]);da("onChange","change click focusin focusout input keydown keyup selectionchange".split(" "));da("onSelect","focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" "));da("onBeforeInput",["compositionend","keypress","textInput","paste"]);da("onCompositionEnd","compositionend focusout keydown keypress keyup mousedown".split(" "));
|
||||
da("onCompositionStart","compositionstart focusout keydown keypress keyup mousedown".split(" "));da("onCompositionUpdate","compositionupdate focusout keydown keypress keyup mousedown".split(" "));var Xe="abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange seeked seeking stalled suspend timeupdate volumechange waiting".split(" "),Ye=new Set("cancel close invalid load scroll toggle".split(" ").concat(Xe));
|
||||
function Ze(a,b,c){var d=a.type||"unknown-event";a.currentTarget=c;Yb(d,b,void 0,a);a.currentTarget=null;}
|
||||
function se(a,b){b=0!==(b&4);for(var c=0;c<a.length;c++){var d=a[c],e=d.event;d=d.listeners;a:{var f=void 0;if(b)for(var g=d.length-1;0<=g;g--){var h=d[g],k=h.instance,l=h.currentTarget;h=h.listener;if(k!==f&&e.isPropagationStopped())break a;Ze(e,h,l);f=k;}else for(g=0;g<d.length;g++){h=d[g];k=h.instance;l=h.currentTarget;h=h.listener;if(k!==f&&e.isPropagationStopped())break a;Ze(e,h,l);f=k;}}}if(Ub)throw a=Vb,Ub=!1,Vb=null,a;}
|
||||
function G(a,b){var c=$e(b),d=a+"__bubble";c.has(d)||(af(b,a,2,!1),c.add(d));}var bf="_reactListening"+Math.random().toString(36).slice(2);function cf(a){a[bf]||(a[bf]=!0,ba.forEach(function(b){Ye.has(b)||df(b,!1,a,null);df(b,!0,a,null);}));}
|
||||
function df(a,b,c,d){var e=4<arguments.length&&void 0!==arguments[4]?arguments[4]:0,f=c;"selectionchange"===a&&9!==c.nodeType&&(f=c.ownerDocument);if(null!==d&&!b&&Ye.has(a)){if("scroll"!==a)return;e|=2;f=d;}var g=$e(f),h=a+"__"+(b?"capture":"bubble");g.has(h)||(b&&(e|=4),af(f,a,e,b),g.add(h));}
|
||||
function af(a,b,c,d){var e=Nc.get(b);switch(void 0===e?2:e){case 0:e=gd;break;case 1:e=id;break;default:e=hd;}c=e.bind(null,b,c,a);e=void 0;!Pb||"touchstart"!==b&&"touchmove"!==b&&"wheel"!==b||(e=!0);d?void 0!==e?a.addEventListener(b,c,{capture:!0,passive:e}):a.addEventListener(b,c,!0):void 0!==e?a.addEventListener(b,c,{passive:e}):a.addEventListener(b,c,!1);}
|
||||
function jd(a,b,c,d,e){var f=d;if(0===(b&1)&&0===(b&2)&&null!==d)a:for(;;){if(null===d)return;var g=d.tag;if(3===g||4===g){var h=d.stateNode.containerInfo;if(h===e||8===h.nodeType&&h.parentNode===e)break;if(4===g)for(g=d.return;null!==g;){var k=g.tag;if(3===k||4===k)if(k=g.stateNode.containerInfo,k===e||8===k.nodeType&&k.parentNode===e)return;g=g.return;}for(;null!==h;){g=wc(h);if(null===g)return;k=g.tag;if(5===k||6===k){d=f=g;continue a}h=h.parentNode;}}d=d.return;}Nb(function(){var d=f,e=xb(c),g=[];
|
||||
a:{var h=Mc.get(a);if(void 0!==h){var k=td,x=a;switch(a){case "keypress":if(0===od(c))break a;case "keydown":case "keyup":k=Rd;break;case "focusin":x="focus";k=Fd;break;case "focusout":x="blur";k=Fd;break;case "beforeblur":case "afterblur":k=Fd;break;case "click":if(2===c.button)break a;case "auxclick":case "dblclick":case "mousedown":case "mousemove":case "mouseup":case "mouseout":case "mouseover":case "contextmenu":k=Bd;break;case "drag":case "dragend":case "dragenter":case "dragexit":case "dragleave":case "dragover":case "dragstart":case "drop":k=
|
||||
Dd;break;case "touchcancel":case "touchend":case "touchmove":case "touchstart":k=Vd;break;case Ic:case Jc:case Kc:k=Hd;break;case Lc:k=Xd;break;case "scroll":k=vd;break;case "wheel":k=Zd;break;case "copy":case "cut":case "paste":k=Jd;break;case "gotpointercapture":case "lostpointercapture":case "pointercancel":case "pointerdown":case "pointermove":case "pointerout":case "pointerover":case "pointerup":k=Td;}var w=0!==(b&4),z=!w&&"scroll"===a,u=w?null!==h?h+"Capture":null:h;w=[];for(var t=d,q;null!==
|
||||
t;){q=t;var v=q.stateNode;5===q.tag&&null!==v&&(q=v,null!==u&&(v=Ob(t,u),null!=v&&w.push(ef(t,v,q))));if(z)break;t=t.return;}0<w.length&&(h=new k(h,x,null,c,e),g.push({event:h,listeners:w}));}}if(0===(b&7)){a:{h="mouseover"===a||"pointerover"===a;k="mouseout"===a||"pointerout"===a;if(h&&0===(b&16)&&(x=c.relatedTarget||c.fromElement)&&(wc(x)||x[ff]))break a;if(k||h){h=e.window===e?e:(h=e.ownerDocument)?h.defaultView||h.parentWindow:window;if(k){if(x=c.relatedTarget||c.toElement,k=d,x=x?wc(x):null,null!==
|
||||
x&&(z=Zb(x),x!==z||5!==x.tag&&6!==x.tag))x=null;}else k=null,x=d;if(k!==x){w=Bd;v="onMouseLeave";u="onMouseEnter";t="mouse";if("pointerout"===a||"pointerover"===a)w=Td,v="onPointerLeave",u="onPointerEnter",t="pointer";z=null==k?h:ue(k);q=null==x?h:ue(x);h=new w(v,t+"leave",k,c,e);h.target=z;h.relatedTarget=q;v=null;wc(e)===d&&(w=new w(u,t+"enter",x,c,e),w.target=q,w.relatedTarget=z,v=w);z=v;if(k&&x)b:{w=k;u=x;t=0;for(q=w;q;q=gf(q))t++;q=0;for(v=u;v;v=gf(v))q++;for(;0<t-q;)w=gf(w),t--;for(;0<q-t;)u=
|
||||
gf(u),q--;for(;t--;){if(w===u||null!==u&&w===u.alternate)break b;w=gf(w);u=gf(u);}w=null;}else w=null;null!==k&&hf(g,h,k,w,!1);null!==x&&null!==z&&hf(g,z,x,w,!0);}}}a:{h=d?ue(d):window;k=h.nodeName&&h.nodeName.toLowerCase();if("select"===k||"input"===k&&"file"===h.type)var J=ve;else if(me(h))if(we)J=Fe;else {J=De;var K=Ce;}else (k=h.nodeName)&&"input"===k.toLowerCase()&&("checkbox"===h.type||"radio"===h.type)&&(J=Ee);if(J&&(J=J(a,d))){ne(g,J,c,e);break a}K&&K(a,h,d);"focusout"===a&&(K=h._wrapperState)&&
|
||||
K.controlled&&"number"===h.type&&bb(h,"number",h.value);}K=d?ue(d):window;switch(a){case "focusin":if(me(K)||"true"===K.contentEditable)Qe=K,Re=d,Se=null;break;case "focusout":Se=Re=Qe=null;break;case "mousedown":Te=!0;break;case "contextmenu":case "mouseup":case "dragend":Te=!1;Ue(g,c,e);break;case "selectionchange":if(Pe)break;case "keydown":case "keyup":Ue(g,c,e);}var Q;if(ae)b:{switch(a){case "compositionstart":var L="onCompositionStart";break b;case "compositionend":L="onCompositionEnd";break b;
|
||||
case "compositionupdate":L="onCompositionUpdate";break b}L=void 0;}else ie?ge(a,c)&&(L="onCompositionEnd"):"keydown"===a&&229===c.keyCode&&(L="onCompositionStart");L&&(de&&"ko"!==c.locale&&(ie||"onCompositionStart"!==L?"onCompositionEnd"===L&&ie&&(Q=nd()):(kd=e,ld="value"in kd?kd.value:kd.textContent,ie=!0)),K=oe(d,L),0<K.length&&(L=new Ld(L,a,null,c,e),g.push({event:L,listeners:K}),Q?L.data=Q:(Q=he(c),null!==Q&&(L.data=Q))));if(Q=ce?je(a,c):ke(a,c))d=oe(d,"onBeforeInput"),0<d.length&&(e=new Ld("onBeforeInput",
|
||||
"beforeinput",null,c,e),g.push({event:e,listeners:d}),e.data=Q);}se(g,b);});}function ef(a,b,c){return {instance:a,listener:b,currentTarget:c}}function oe(a,b){for(var c=b+"Capture",d=[];null!==a;){var e=a,f=e.stateNode;5===e.tag&&null!==f&&(e=f,f=Ob(a,c),null!=f&&d.unshift(ef(a,f,e)),f=Ob(a,b),null!=f&&d.push(ef(a,f,e)));a=a.return;}return d}function gf(a){if(null===a)return null;do a=a.return;while(a&&5!==a.tag);return a?a:null}
|
||||
function hf(a,b,c,d,e){for(var f=b._reactName,g=[];null!==c&&c!==d;){var h=c,k=h.alternate,l=h.stateNode;if(null!==k&&k===d)break;5===h.tag&&null!==l&&(h=l,e?(k=Ob(c,f),null!=k&&g.unshift(ef(c,k,h))):e||(k=Ob(c,f),null!=k&&g.push(ef(c,k,h))));c=c.return;}0!==g.length&&a.push({event:b,listeners:g});}function jf(){}var kf=null,lf=null;function mf(a,b){switch(a){case "button":case "input":case "select":case "textarea":return !!b.autoFocus}return !1}
|
||||
function nf(a,b){return "textarea"===a||"option"===a||"noscript"===a||"string"===typeof b.children||"number"===typeof b.children||"object"===typeof b.dangerouslySetInnerHTML&&null!==b.dangerouslySetInnerHTML&&null!=b.dangerouslySetInnerHTML.__html}var of="function"===typeof setTimeout?setTimeout:void 0,pf="function"===typeof clearTimeout?clearTimeout:void 0;function qf(a){1===a.nodeType?a.textContent="":9===a.nodeType&&(a=a.body,null!=a&&(a.textContent=""));}
|
||||
function rf(a){for(;null!=a;a=a.nextSibling){var b=a.nodeType;if(1===b||3===b)break}return a}function sf(a){a=a.previousSibling;for(var b=0;a;){if(8===a.nodeType){var c=a.data;if("$"===c||"$!"===c||"$?"===c){if(0===b)return a;b--;}else "/$"===c&&b++;}a=a.previousSibling;}return null}var tf=0;function uf(a){return {$$typeof:Ga,toString:a,valueOf:a}}var vf=Math.random().toString(36).slice(2),wf="__reactFiber$"+vf,xf="__reactProps$"+vf,ff="__reactContainer$"+vf,yf="__reactEvents$"+vf;
|
||||
function wc(a){var b=a[wf];if(b)return b;for(var c=a.parentNode;c;){if(b=c[ff]||c[wf]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=sf(a);null!==a;){if(c=a[wf])return c;a=sf(a);}return b}a=c;c=a.parentNode;}return null}function Cb(a){a=a[wf]||a[ff];return !a||5!==a.tag&&6!==a.tag&&13!==a.tag&&3!==a.tag?null:a}function ue(a){if(5===a.tag||6===a.tag)return a.stateNode;throw Error(y(33));}function Db(a){return a[xf]||null}
|
||||
function $e(a){var b=a[yf];void 0===b&&(b=a[yf]=new Set);return b}var zf=[],Af=-1;function Bf(a){return {current:a}}function H(a){0>Af||(a.current=zf[Af],zf[Af]=null,Af--);}function I(a,b){Af++;zf[Af]=a.current;a.current=b;}var Cf={},M=Bf(Cf),N=Bf(!1),Df=Cf;
|
||||
function Ef(a,b){var c=a.type.contextTypes;if(!c)return Cf;var d=a.stateNode;if(d&&d.__reactInternalMemoizedUnmaskedChildContext===b)return d.__reactInternalMemoizedMaskedChildContext;var e={},f;for(f in c)e[f]=b[f];d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=b,a.__reactInternalMemoizedMaskedChildContext=e);return e}function Ff(a){a=a.childContextTypes;return null!==a&&void 0!==a}function Gf(){H(N);H(M);}function Hf(a,b,c){if(M.current!==Cf)throw Error(y(168));I(M,b);I(N,c);}
|
||||
function If(a,b,c){var d=a.stateNode;a=b.childContextTypes;if("function"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in a))throw Error(y(108,Ra(b)||"Unknown",e));return objectAssign({},c,d)}function Jf(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||Cf;Df=M.current;I(M,a);I(N,N.current);return !0}function Kf(a,b,c){var d=a.stateNode;if(!d)throw Error(y(169));c?(a=If(a,b,Df),d.__reactInternalMemoizedMergedChildContext=a,H(N),H(M),I(M,a)):H(N);I(N,c);}
|
||||
var Lf=null,Mf=null,Nf=scheduler.unstable_runWithPriority,Of=scheduler.unstable_scheduleCallback,Pf=scheduler.unstable_cancelCallback,Qf=scheduler.unstable_shouldYield,Rf=scheduler.unstable_requestPaint,Sf=scheduler.unstable_now,Tf=scheduler.unstable_getCurrentPriorityLevel,Uf=scheduler.unstable_ImmediatePriority,Vf=scheduler.unstable_UserBlockingPriority,Wf=scheduler.unstable_NormalPriority,Xf=scheduler.unstable_LowPriority,Yf=scheduler.unstable_IdlePriority,Zf={},$f=void 0!==Rf?Rf:function(){},ag=null,bg=null,cg=!1,dg=Sf(),O=1E4>dg?Sf:function(){return Sf()-dg};
|
||||
function eg(){switch(Tf()){case Uf:return 99;case Vf:return 98;case Wf:return 97;case Xf:return 96;case Yf:return 95;default:throw Error(y(332));}}function fg(a){switch(a){case 99:return Uf;case 98:return Vf;case 97:return Wf;case 96:return Xf;case 95:return Yf;default:throw Error(y(332));}}function gg(a,b){a=fg(a);return Nf(a,b)}function hg(a,b,c){a=fg(a);return Of(a,b,c)}function ig(){if(null!==bg){var a=bg;bg=null;Pf(a);}jg();}
|
||||
function jg(){if(!cg&&null!==ag){cg=!0;var a=0;try{var b=ag;gg(99,function(){for(;a<b.length;a++){var c=b[a];do c=c(!0);while(null!==c)}});ag=null;}catch(c){throw null!==ag&&(ag=ag.slice(a+1)),Of(Uf,ig),c;}finally{cg=!1;}}}var kg=ra.ReactCurrentBatchConfig;function lg(a,b){if(a&&a.defaultProps){b=objectAssign({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}var mg=Bf(null),ng=null,og=null,pg=null;function qg(){pg=og=ng=null;}
|
||||
function rg(a){var b=mg.current;H(mg);a.type._context._currentValue=b;}function sg(a,b){for(;null!==a;){var c=a.alternate;if((a.childLanes&b)===b)if(null===c||(c.childLanes&b)===b)break;else c.childLanes|=b;else a.childLanes|=b,null!==c&&(c.childLanes|=b);a=a.return;}}function tg(a,b){ng=a;pg=og=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!==(a.lanes&b)&&(ug=!0),a.firstContext=null);}
|
||||
function vg(a,b){if(pg!==a&&!1!==b&&0!==b){if("number"!==typeof b||1073741823===b)pg=a,b=1073741823;b={context:a,observedBits:b,next:null};if(null===og){if(null===ng)throw Error(y(308));og=b;ng.dependencies={lanes:0,firstContext:b,responders:null};}else og=og.next=b;}return a._currentValue}var wg=!1;function xg(a){a.updateQueue={baseState:a.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null},effects:null};}
|
||||
function yg(a,b){a=a.updateQueue;b.updateQueue===a&&(b.updateQueue={baseState:a.baseState,firstBaseUpdate:a.firstBaseUpdate,lastBaseUpdate:a.lastBaseUpdate,shared:a.shared,effects:a.effects});}function zg(a,b){return {eventTime:a,lane:b,tag:0,payload:null,callback:null,next:null}}function Ag(a,b){a=a.updateQueue;if(null!==a){a=a.shared;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b;}}
|
||||
function Bg(a,b){var c=a.updateQueue,d=a.alternate;if(null!==d&&(d=d.updateQueue,c===d)){var e=null,f=null;c=c.firstBaseUpdate;if(null!==c){do{var g={eventTime:c.eventTime,lane:c.lane,tag:c.tag,payload:c.payload,callback:c.callback,next:null};null===f?e=f=g:f=f.next=g;c=c.next;}while(null!==c);null===f?e=f=b:f=f.next=b;}else e=f=b;c={baseState:d.baseState,firstBaseUpdate:e,lastBaseUpdate:f,shared:d.shared,effects:d.effects};a.updateQueue=c;return}a=c.lastBaseUpdate;null===a?c.firstBaseUpdate=b:a.next=
|
||||
b;c.lastBaseUpdate=b;}
|
||||
function Cg(a,b,c,d){var e=a.updateQueue;wg=!1;var f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h){e.shared.pending=null;var k=h,l=k.next;k.next=null;null===g?f=l:g.next=l;g=k;var n=a.alternate;if(null!==n){n=n.updateQueue;var A=n.lastBaseUpdate;A!==g&&(null===A?n.firstBaseUpdate=l:A.next=l,n.lastBaseUpdate=k);}}if(null!==f){A=e.baseState;g=0;n=l=k=null;do{h=f.lane;var p=f.eventTime;if((d&h)===h){null!==n&&(n=n.next={eventTime:p,lane:0,tag:f.tag,payload:f.payload,callback:f.callback,
|
||||
next:null});a:{var C=a,x=f;h=b;p=c;switch(x.tag){case 1:C=x.payload;if("function"===typeof C){A=C.call(p,A,h);break a}A=C;break a;case 3:C.flags=C.flags&-4097|64;case 0:C=x.payload;h="function"===typeof C?C.call(p,A,h):C;if(null===h||void 0===h)break a;A=objectAssign({},A,h);break a;case 2:wg=!0;}}null!==f.callback&&(a.flags|=32,h=e.effects,null===h?e.effects=[f]:h.push(f));}else p={eventTime:p,lane:h,tag:f.tag,payload:f.payload,callback:f.callback,next:null},null===n?(l=n=p,k=A):n=n.next=p,g|=h;f=f.next;if(null===
|
||||
f)if(h=e.shared.pending,null===h)break;else f=h.next,h.next=null,e.lastBaseUpdate=h,e.shared.pending=null;}while(1);null===n&&(k=A);e.baseState=k;e.firstBaseUpdate=l;e.lastBaseUpdate=n;Dg|=g;a.lanes=g;a.memoizedState=A;}}function Eg(a,b,c){a=b.effects;b.effects=null;if(null!==a)for(b=0;b<a.length;b++){var d=a[b],e=d.callback;if(null!==e){d.callback=null;d=c;if("function"!==typeof e)throw Error(y(191,e));e.call(d);}}}var Fg=(new react.Component).refs;
|
||||
function Gg(a,b,c,d){b=a.memoizedState;c=c(d,b);c=null===c||void 0===c?b:objectAssign({},b,c);a.memoizedState=c;0===a.lanes&&(a.updateQueue.baseState=c);}
|
||||
var Kg={isMounted:function(a){return (a=a._reactInternals)?Zb(a)===a:!1},enqueueSetState:function(a,b,c){a=a._reactInternals;var d=Hg(),e=Ig(a),f=zg(d,e);f.payload=b;void 0!==c&&null!==c&&(f.callback=c);Ag(a,f);Jg(a,e,d);},enqueueReplaceState:function(a,b,c){a=a._reactInternals;var d=Hg(),e=Ig(a),f=zg(d,e);f.tag=1;f.payload=b;void 0!==c&&null!==c&&(f.callback=c);Ag(a,f);Jg(a,e,d);},enqueueForceUpdate:function(a,b){a=a._reactInternals;var c=Hg(),d=Ig(a),e=zg(c,d);e.tag=2;void 0!==b&&null!==b&&(e.callback=
|
||||
b);Ag(a,e);Jg(a,d,c);}};function Lg(a,b,c,d,e,f,g){a=a.stateNode;return "function"===typeof a.shouldComponentUpdate?a.shouldComponentUpdate(d,f,g):b.prototype&&b.prototype.isPureReactComponent?!Je(c,d)||!Je(e,f):!0}
|
||||
function Mg(a,b,c){var d=!1,e=Cf;var f=b.contextType;"object"===typeof f&&null!==f?f=vg(f):(e=Ff(b)?Df:M.current,d=b.contextTypes,f=(d=null!==d&&void 0!==d)?Ef(a,e):Cf);b=new b(c,f);a.memoizedState=null!==b.state&&void 0!==b.state?b.state:null;b.updater=Kg;a.stateNode=b;b._reactInternals=a;d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=e,a.__reactInternalMemoizedMaskedChildContext=f);return b}
|
||||
function Ng(a,b,c,d){a=b.state;"function"===typeof b.componentWillReceiveProps&&b.componentWillReceiveProps(c,d);"function"===typeof b.UNSAFE_componentWillReceiveProps&&b.UNSAFE_componentWillReceiveProps(c,d);b.state!==a&&Kg.enqueueReplaceState(b,b.state,null);}
|
||||
function Og(a,b,c,d){var e=a.stateNode;e.props=c;e.state=a.memoizedState;e.refs=Fg;xg(a);var f=b.contextType;"object"===typeof f&&null!==f?e.context=vg(f):(f=Ff(b)?Df:M.current,e.context=Ef(a,f));Cg(a,c,e,d);e.state=a.memoizedState;f=b.getDerivedStateFromProps;"function"===typeof f&&(Gg(a,b,f,c),e.state=a.memoizedState);"function"===typeof b.getDerivedStateFromProps||"function"===typeof e.getSnapshotBeforeUpdate||"function"!==typeof e.UNSAFE_componentWillMount&&"function"!==typeof e.componentWillMount||
|
||||
(b=e.state,"function"===typeof e.componentWillMount&&e.componentWillMount(),"function"===typeof e.UNSAFE_componentWillMount&&e.UNSAFE_componentWillMount(),b!==e.state&&Kg.enqueueReplaceState(e,e.state,null),Cg(a,c,e,d),e.state=a.memoizedState);"function"===typeof e.componentDidMount&&(a.flags|=4);}var Pg=Array.isArray;
|
||||
function Qg(a,b,c){a=c.ref;if(null!==a&&"function"!==typeof a&&"object"!==typeof a){if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(y(309));var d=c.stateNode;}if(!d)throw Error(y(147,a));var e=""+a;if(null!==b&&null!==b.ref&&"function"===typeof b.ref&&b.ref._stringRef===e)return b.ref;b=function(a){var b=d.refs;b===Fg&&(b=d.refs={});null===a?delete b[e]:b[e]=a;};b._stringRef=e;return b}if("string"!==typeof a)throw Error(y(284));if(!c._owner)throw Error(y(290,a));}return a}
|
||||
function Rg(a,b){if("textarea"!==a.type)throw Error(y(31,"[object Object]"===Object.prototype.toString.call(b)?"object with keys {"+Object.keys(b).join(", ")+"}":b));}
|
||||
function Sg(a){function b(b,c){if(a){var d=b.lastEffect;null!==d?(d.nextEffect=c,b.lastEffect=c):b.firstEffect=b.lastEffect=c;c.nextEffect=null;c.flags=8;}}function c(c,d){if(!a)return null;for(;null!==d;)b(c,d),d=d.sibling;return null}function d(a,b){for(a=new Map;null!==b;)null!==b.key?a.set(b.key,b):a.set(b.index,b),b=b.sibling;return a}function e(a,b){a=Tg(a,b);a.index=0;a.sibling=null;return a}function f(b,c,d){b.index=d;if(!a)return c;d=b.alternate;if(null!==d)return d=d.index,d<c?(b.flags=2,
|
||||
c):d;b.flags=2;return c}function g(b){a&&null===b.alternate&&(b.flags=2);return b}function h(a,b,c,d){if(null===b||6!==b.tag)return b=Ug(c,a.mode,d),b.return=a,b;b=e(b,c);b.return=a;return b}function k(a,b,c,d){if(null!==b&&b.elementType===c.type)return d=e(b,c.props),d.ref=Qg(a,b,c),d.return=a,d;d=Vg(c.type,c.key,c.props,null,a.mode,d);d.ref=Qg(a,b,c);d.return=a;return d}function l(a,b,c,d){if(null===b||4!==b.tag||b.stateNode.containerInfo!==c.containerInfo||b.stateNode.implementation!==c.implementation)return b=
|
||||
Wg(c,a.mode,d),b.return=a,b;b=e(b,c.children||[]);b.return=a;return b}function n(a,b,c,d,f){if(null===b||7!==b.tag)return b=Xg(c,a.mode,d,f),b.return=a,b;b=e(b,c);b.return=a;return b}function A(a,b,c){if("string"===typeof b||"number"===typeof b)return b=Ug(""+b,a.mode,c),b.return=a,b;if("object"===typeof b&&null!==b){switch(b.$$typeof){case sa:return c=Vg(b.type,b.key,b.props,null,a.mode,c),c.ref=Qg(a,null,b),c.return=a,c;case ta:return b=Wg(b,a.mode,c),b.return=a,b}if(Pg(b)||La(b))return b=Xg(b,
|
||||
a.mode,c,null),b.return=a,b;Rg(a,b);}return null}function p(a,b,c,d){var e=null!==b?b.key:null;if("string"===typeof c||"number"===typeof c)return null!==e?null:h(a,b,""+c,d);if("object"===typeof c&&null!==c){switch(c.$$typeof){case sa:return c.key===e?c.type===ua?n(a,b,c.props.children,d,e):k(a,b,c,d):null;case ta:return c.key===e?l(a,b,c,d):null}if(Pg(c)||La(c))return null!==e?null:n(a,b,c,d,null);Rg(a,c);}return null}function C(a,b,c,d,e){if("string"===typeof d||"number"===typeof d)return a=a.get(c)||
|
||||
null,h(b,a,""+d,e);if("object"===typeof d&&null!==d){switch(d.$$typeof){case sa:return a=a.get(null===d.key?c:d.key)||null,d.type===ua?n(b,a,d.props.children,e,d.key):k(b,a,d,e);case ta:return a=a.get(null===d.key?c:d.key)||null,l(b,a,d,e)}if(Pg(d)||La(d))return a=a.get(c)||null,n(b,a,d,e,null);Rg(b,d);}return null}function x(e,g,h,k){for(var l=null,t=null,u=g,z=g=0,q=null;null!==u&&z<h.length;z++){u.index>z?(q=u,u=null):q=u.sibling;var n=p(e,u,h[z],k);if(null===n){null===u&&(u=q);break}a&&u&&null===
|
||||
n.alternate&&b(e,u);g=f(n,g,z);null===t?l=n:t.sibling=n;t=n;u=q;}if(z===h.length)return c(e,u),l;if(null===u){for(;z<h.length;z++)u=A(e,h[z],k),null!==u&&(g=f(u,g,z),null===t?l=u:t.sibling=u,t=u);return l}for(u=d(e,u);z<h.length;z++)q=C(u,e,z,h[z],k),null!==q&&(a&&null!==q.alternate&&u.delete(null===q.key?z:q.key),g=f(q,g,z),null===t?l=q:t.sibling=q,t=q);a&&u.forEach(function(a){return b(e,a)});return l}function w(e,g,h,k){var l=La(h);if("function"!==typeof l)throw Error(y(150));h=l.call(h);if(null==
|
||||
h)throw Error(y(151));for(var t=l=null,u=g,z=g=0,q=null,n=h.next();null!==u&&!n.done;z++,n=h.next()){u.index>z?(q=u,u=null):q=u.sibling;var w=p(e,u,n.value,k);if(null===w){null===u&&(u=q);break}a&&u&&null===w.alternate&&b(e,u);g=f(w,g,z);null===t?l=w:t.sibling=w;t=w;u=q;}if(n.done)return c(e,u),l;if(null===u){for(;!n.done;z++,n=h.next())n=A(e,n.value,k),null!==n&&(g=f(n,g,z),null===t?l=n:t.sibling=n,t=n);return l}for(u=d(e,u);!n.done;z++,n=h.next())n=C(u,e,z,n.value,k),null!==n&&(a&&null!==n.alternate&&
|
||||
u.delete(null===n.key?z:n.key),g=f(n,g,z),null===t?l=n:t.sibling=n,t=n);a&&u.forEach(function(a){return b(e,a)});return l}return function(a,d,f,h){var k="object"===typeof f&&null!==f&&f.type===ua&&null===f.key;k&&(f=f.props.children);var l="object"===typeof f&&null!==f;if(l)switch(f.$$typeof){case sa:a:{l=f.key;for(k=d;null!==k;){if(k.key===l){switch(k.tag){case 7:if(f.type===ua){c(a,k.sibling);d=e(k,f.props.children);d.return=a;a=d;break a}break;default:if(k.elementType===f.type){c(a,k.sibling);
|
||||
d=e(k,f.props);d.ref=Qg(a,k,f);d.return=a;a=d;break a}}c(a,k);break}else b(a,k);k=k.sibling;}f.type===ua?(d=Xg(f.props.children,a.mode,h,f.key),d.return=a,a=d):(h=Vg(f.type,f.key,f.props,null,a.mode,h),h.ref=Qg(a,d,f),h.return=a,a=h);}return g(a);case ta:a:{for(k=f.key;null!==d;){if(d.key===k)if(4===d.tag&&d.stateNode.containerInfo===f.containerInfo&&d.stateNode.implementation===f.implementation){c(a,d.sibling);d=e(d,f.children||[]);d.return=a;a=d;break a}else {c(a,d);break}else b(a,d);d=d.sibling;}d=
|
||||
Wg(f,a.mode,h);d.return=a;a=d;}return g(a)}if("string"===typeof f||"number"===typeof f)return f=""+f,null!==d&&6===d.tag?(c(a,d.sibling),d=e(d,f),d.return=a,a=d):(c(a,d),d=Ug(f,a.mode,h),d.return=a,a=d),g(a);if(Pg(f))return x(a,d,f,h);if(La(f))return w(a,d,f,h);l&&Rg(a,f);if("undefined"===typeof f&&!k)switch(a.tag){case 1:case 22:case 0:case 11:case 15:throw Error(y(152,Ra(a.type)||"Component"));}return c(a,d)}}var Yg=Sg(!0),Zg=Sg(!1),$g={},ah=Bf($g),bh=Bf($g),ch=Bf($g);
|
||||
function dh(a){if(a===$g)throw Error(y(174));return a}function eh(a,b){I(ch,b);I(bh,a);I(ah,$g);a=b.nodeType;switch(a){case 9:case 11:b=(b=b.documentElement)?b.namespaceURI:mb(null,"");break;default:a=8===a?b.parentNode:b,b=a.namespaceURI||null,a=a.tagName,b=mb(b,a);}H(ah);I(ah,b);}function fh(){H(ah);H(bh);H(ch);}function gh(a){dh(ch.current);var b=dh(ah.current);var c=mb(b,a.type);b!==c&&(I(bh,a),I(ah,c));}function hh(a){bh.current===a&&(H(ah),H(bh));}var P=Bf(0);
|
||||
function ih(a){for(var b=a;null!==b;){if(13===b.tag){var c=b.memoizedState;if(null!==c&&(c=c.dehydrated,null===c||"$?"===c.data||"$!"===c.data))return b}else if(19===b.tag&&void 0!==b.memoizedProps.revealOrder){if(0!==(b.flags&64))return b}else if(null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return null;b=b.return;}b.sibling.return=b.return;b=b.sibling;}return null}var jh=null,kh=null,lh=!1;
|
||||
function mh(a,b){var c=nh(5,null,null,0);c.elementType="DELETED";c.type="DELETED";c.stateNode=b;c.return=a;c.flags=8;null!==a.lastEffect?(a.lastEffect.nextEffect=c,a.lastEffect=c):a.firstEffect=a.lastEffect=c;}function oh(a,b){switch(a.tag){case 5:var c=a.type;b=1!==b.nodeType||c.toLowerCase()!==b.nodeName.toLowerCase()?null:b;return null!==b?(a.stateNode=b,!0):!1;case 6:return b=""===a.pendingProps||3!==b.nodeType?null:b,null!==b?(a.stateNode=b,!0):!1;case 13:return !1;default:return !1}}
|
||||
function ph(a){if(lh){var b=kh;if(b){var c=b;if(!oh(a,b)){b=rf(c.nextSibling);if(!b||!oh(a,b)){a.flags=a.flags&-1025|2;lh=!1;jh=a;return}mh(jh,c);}jh=a;kh=rf(b.firstChild);}else a.flags=a.flags&-1025|2,lh=!1,jh=a;}}function qh(a){for(a=a.return;null!==a&&5!==a.tag&&3!==a.tag&&13!==a.tag;)a=a.return;jh=a;}
|
||||
function rh(a){if(a!==jh)return !1;if(!lh)return qh(a),lh=!0,!1;var b=a.type;if(5!==a.tag||"head"!==b&&"body"!==b&&!nf(b,a.memoizedProps))for(b=kh;b;)mh(a,b),b=rf(b.nextSibling);qh(a);if(13===a.tag){a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(y(317));a:{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType){var c=a.data;if("/$"===c){if(0===b){kh=rf(a.nextSibling);break a}b--;}else "$"!==c&&"$!"!==c&&"$?"!==c||b++;}a=a.nextSibling;}kh=null;}}else kh=jh?rf(a.stateNode.nextSibling):null;return !0}
|
||||
function sh(){kh=jh=null;lh=!1;}var th=[];function uh(){for(var a=0;a<th.length;a++)th[a]._workInProgressVersionPrimary=null;th.length=0;}var vh=ra.ReactCurrentDispatcher,wh=ra.ReactCurrentBatchConfig,xh=0,R=null,S=null,T=null,yh=!1,zh=!1;function Ah(){throw Error(y(321));}function Bh(a,b){if(null===b)return !1;for(var c=0;c<b.length&&c<a.length;c++)if(!He(a[c],b[c]))return !1;return !0}
|
||||
function Ch(a,b,c,d,e,f){xh=f;R=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;vh.current=null===a||null===a.memoizedState?Dh:Eh;a=c(d,e);if(zh){f=0;do{zh=!1;if(!(25>f))throw Error(y(301));f+=1;T=S=null;b.updateQueue=null;vh.current=Fh;a=c(d,e);}while(zh)}vh.current=Gh;b=null!==S&&null!==S.next;xh=0;T=S=R=null;yh=!1;if(b)throw Error(y(300));return a}function Hh(){var a={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};null===T?R.memoizedState=T=a:T=T.next=a;return T}
|
||||
function Ih(){if(null===S){var a=R.alternate;a=null!==a?a.memoizedState:null;}else a=S.next;var b=null===T?R.memoizedState:T.next;if(null!==b)T=b,S=a;else {if(null===a)throw Error(y(310));S=a;a={memoizedState:S.memoizedState,baseState:S.baseState,baseQueue:S.baseQueue,queue:S.queue,next:null};null===T?R.memoizedState=T=a:T=T.next=a;}return T}function Jh(a,b){return "function"===typeof b?b(a):b}
|
||||
function Kh(a){var b=Ih(),c=b.queue;if(null===c)throw Error(y(311));c.lastRenderedReducer=a;var d=S,e=d.baseQueue,f=c.pending;if(null!==f){if(null!==e){var g=e.next;e.next=f.next;f.next=g;}d.baseQueue=e=f;c.pending=null;}if(null!==e){e=e.next;d=d.baseState;var h=g=f=null,k=e;do{var l=k.lane;if((xh&l)===l)null!==h&&(h=h.next={lane:0,action:k.action,eagerReducer:k.eagerReducer,eagerState:k.eagerState,next:null}),d=k.eagerReducer===a?k.eagerState:a(d,k.action);else {var n={lane:l,action:k.action,eagerReducer:k.eagerReducer,
|
||||
eagerState:k.eagerState,next:null};null===h?(g=h=n,f=d):h=h.next=n;R.lanes|=l;Dg|=l;}k=k.next;}while(null!==k&&k!==e);null===h?f=d:h.next=g;He(d,b.memoizedState)||(ug=!0);b.memoizedState=d;b.baseState=f;b.baseQueue=h;c.lastRenderedState=d;}return [b.memoizedState,c.dispatch]}
|
||||
function Lh(a){var b=Ih(),c=b.queue;if(null===c)throw Error(y(311));c.lastRenderedReducer=a;var d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);He(f,b.memoizedState)||(ug=!0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f;}return [f,d]}
|
||||
function Mh(a,b,c){var d=b._getVersion;d=d(b._source);var e=b._workInProgressVersionPrimary;if(null!==e)a=e===d;else if(a=a.mutableReadLanes,a=(xh&a)===a)b._workInProgressVersionPrimary=d,th.push(b);if(a)return c(b._source);th.push(b);throw Error(y(350));}
|
||||
function Nh(a,b,c,d){var e=U;if(null===e)throw Error(y(349));var f=b._getVersion,g=f(b._source),h=vh.current,k=h.useState(function(){return Mh(e,b,c)}),l=k[1],n=k[0];k=T;var A=a.memoizedState,p=A.refs,C=p.getSnapshot,x=A.source;A=A.subscribe;var w=R;a.memoizedState={refs:p,source:b,subscribe:d};h.useEffect(function(){p.getSnapshot=c;p.setSnapshot=l;var a=f(b._source);if(!He(g,a)){a=c(b._source);He(n,a)||(l(a),a=Ig(w),e.mutableReadLanes|=a&e.pendingLanes);a=e.mutableReadLanes;e.entangledLanes|=a;for(var d=
|
||||
e.entanglements,h=a;0<h;){var k=31-Vc(h),v=1<<k;d[k]|=a;h&=~v;}}},[c,b,d]);h.useEffect(function(){return d(b._source,function(){var a=p.getSnapshot,c=p.setSnapshot;try{c(a(b._source));var d=Ig(w);e.mutableReadLanes|=d&e.pendingLanes;}catch(q){c(function(){throw q;});}})},[b,d]);He(C,c)&&He(x,b)&&He(A,d)||(a={pending:null,dispatch:null,lastRenderedReducer:Jh,lastRenderedState:n},a.dispatch=l=Oh.bind(null,R,a),k.queue=a,k.baseQueue=null,n=Mh(e,b,c),k.memoizedState=k.baseState=n);return n}
|
||||
function Ph(a,b,c){var d=Ih();return Nh(d,a,b,c)}function Qh(a){var b=Hh();"function"===typeof a&&(a=a());b.memoizedState=b.baseState=a;a=b.queue={pending:null,dispatch:null,lastRenderedReducer:Jh,lastRenderedState:a};a=a.dispatch=Oh.bind(null,R,a);return [b.memoizedState,a]}
|
||||
function Rh(a,b,c,d){a={tag:a,create:b,destroy:c,deps:d,next:null};b=R.updateQueue;null===b?(b={lastEffect:null},R.updateQueue=b,b.lastEffect=a.next=a):(c=b.lastEffect,null===c?b.lastEffect=a.next=a:(d=c.next,c.next=a,a.next=d,b.lastEffect=a));return a}function Sh(a){var b=Hh();a={current:a};return b.memoizedState=a}function Th(){return Ih().memoizedState}function Uh(a,b,c,d){var e=Hh();R.flags|=a;e.memoizedState=Rh(1|b,c,void 0,void 0===d?null:d);}
|
||||
function Vh(a,b,c,d){var e=Ih();d=void 0===d?null:d;var f=void 0;if(null!==S){var g=S.memoizedState;f=g.destroy;if(null!==d&&Bh(d,g.deps)){Rh(b,c,f,d);return}}R.flags|=a;e.memoizedState=Rh(1|b,c,f,d);}function Wh(a,b){return Uh(516,4,a,b)}function Xh(a,b){return Vh(516,4,a,b)}function Yh(a,b){return Vh(4,2,a,b)}function Zh(a,b){if("function"===typeof b)return a=a(),b(a),function(){b(null);};if(null!==b&&void 0!==b)return a=a(),b.current=a,function(){b.current=null;}}
|
||||
function $h(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;return Vh(4,2,Zh.bind(null,b,a),c)}function ai(){}function bi(a,b){var c=Ih();b=void 0===b?null:b;var d=c.memoizedState;if(null!==d&&null!==b&&Bh(b,d[1]))return d[0];c.memoizedState=[a,b];return a}function ci(a,b){var c=Ih();b=void 0===b?null:b;var d=c.memoizedState;if(null!==d&&null!==b&&Bh(b,d[1]))return d[0];a=a();c.memoizedState=[a,b];return a}
|
||||
function di(a,b){var c=eg();gg(98>c?98:c,function(){a(!0);});gg(97<c?97:c,function(){var c=wh.transition;wh.transition=1;try{a(!1),b();}finally{wh.transition=c;}});}
|
||||
function Oh(a,b,c){var d=Hg(),e=Ig(a),f={lane:e,action:c,eagerReducer:null,eagerState:null,next:null},g=b.pending;null===g?f.next=f:(f.next=g.next,g.next=f);b.pending=f;g=a.alternate;if(a===R||null!==g&&g===R)zh=yh=!0;else {if(0===a.lanes&&(null===g||0===g.lanes)&&(g=b.lastRenderedReducer,null!==g))try{var h=b.lastRenderedState,k=g(h,c);f.eagerReducer=g;f.eagerState=k;if(He(k,h))return}catch(l){}finally{}Jg(a,e,d);}}
|
||||
var Gh={readContext:vg,useCallback:Ah,useContext:Ah,useEffect:Ah,useImperativeHandle:Ah,useLayoutEffect:Ah,useMemo:Ah,useReducer:Ah,useRef:Ah,useState:Ah,useDebugValue:Ah,useDeferredValue:Ah,useTransition:Ah,useMutableSource:Ah,useOpaqueIdentifier:Ah,unstable_isNewReconciler:!1},Dh={readContext:vg,useCallback:function(a,b){Hh().memoizedState=[a,void 0===b?null:b];return a},useContext:vg,useEffect:Wh,useImperativeHandle:function(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;return Uh(4,2,Zh.bind(null,
|
||||
b,a),c)},useLayoutEffect:function(a,b){return Uh(4,2,a,b)},useMemo:function(a,b){var c=Hh();b=void 0===b?null:b;a=a();c.memoizedState=[a,b];return a},useReducer:function(a,b,c){var d=Hh();b=void 0!==c?c(b):b;d.memoizedState=d.baseState=b;a=d.queue={pending:null,dispatch:null,lastRenderedReducer:a,lastRenderedState:b};a=a.dispatch=Oh.bind(null,R,a);return [d.memoizedState,a]},useRef:Sh,useState:Qh,useDebugValue:ai,useDeferredValue:function(a){var b=Qh(a),c=b[0],d=b[1];Wh(function(){var b=wh.transition;
|
||||
wh.transition=1;try{d(a);}finally{wh.transition=b;}},[a]);return c},useTransition:function(){var a=Qh(!1),b=a[0];a=di.bind(null,a[1]);Sh(a);return [a,b]},useMutableSource:function(a,b,c){var d=Hh();d.memoizedState={refs:{getSnapshot:b,setSnapshot:null},source:a,subscribe:c};return Nh(d,a,b,c)},useOpaqueIdentifier:function(){if(lh){var a=!1,b=uf(function(){a||(a=!0,c("r:"+(tf++).toString(36)));throw Error(y(355));}),c=Qh(b)[1];0===(R.mode&2)&&(R.flags|=516,Rh(5,function(){c("r:"+(tf++).toString(36));},
|
||||
void 0,null));return b}b="r:"+(tf++).toString(36);Qh(b);return b},unstable_isNewReconciler:!1},Eh={readContext:vg,useCallback:bi,useContext:vg,useEffect:Xh,useImperativeHandle:$h,useLayoutEffect:Yh,useMemo:ci,useReducer:Kh,useRef:Th,useState:function(){return Kh(Jh)},useDebugValue:ai,useDeferredValue:function(a){var b=Kh(Jh),c=b[0],d=b[1];Xh(function(){var b=wh.transition;wh.transition=1;try{d(a);}finally{wh.transition=b;}},[a]);return c},useTransition:function(){var a=Kh(Jh)[0];return [Th().current,
|
||||
a]},useMutableSource:Ph,useOpaqueIdentifier:function(){return Kh(Jh)[0]},unstable_isNewReconciler:!1},Fh={readContext:vg,useCallback:bi,useContext:vg,useEffect:Xh,useImperativeHandle:$h,useLayoutEffect:Yh,useMemo:ci,useReducer:Lh,useRef:Th,useState:function(){return Lh(Jh)},useDebugValue:ai,useDeferredValue:function(a){var b=Lh(Jh),c=b[0],d=b[1];Xh(function(){var b=wh.transition;wh.transition=1;try{d(a);}finally{wh.transition=b;}},[a]);return c},useTransition:function(){var a=Lh(Jh)[0];return [Th().current,
|
||||
a]},useMutableSource:Ph,useOpaqueIdentifier:function(){return Lh(Jh)[0]},unstable_isNewReconciler:!1},ei=ra.ReactCurrentOwner,ug=!1;function fi(a,b,c,d){b.child=null===a?Zg(b,null,c,d):Yg(b,a.child,c,d);}function gi(a,b,c,d,e){c=c.render;var f=b.ref;tg(b,e);d=Ch(a,b,c,d,f,e);if(null!==a&&!ug)return b.updateQueue=a.updateQueue,b.flags&=-517,a.lanes&=~e,hi(a,b,e);b.flags|=1;fi(a,b,d,e);return b.child}
|
||||
function ii(a,b,c,d,e,f){if(null===a){var g=c.type;if("function"===typeof g&&!ji(g)&&void 0===g.defaultProps&&null===c.compare&&void 0===c.defaultProps)return b.tag=15,b.type=g,ki(a,b,g,d,e,f);a=Vg(c.type,null,d,b,b.mode,f);a.ref=b.ref;a.return=b;return b.child=a}g=a.child;if(0===(e&f)&&(e=g.memoizedProps,c=c.compare,c=null!==c?c:Je,c(e,d)&&a.ref===b.ref))return hi(a,b,f);b.flags|=1;a=Tg(g,d);a.ref=b.ref;a.return=b;return b.child=a}
|
||||
function ki(a,b,c,d,e,f){if(null!==a&&Je(a.memoizedProps,d)&&a.ref===b.ref)if(ug=!1,0!==(f&e))0!==(a.flags&16384)&&(ug=!0);else return b.lanes=a.lanes,hi(a,b,f);return li(a,b,c,d,f)}
|
||||
function mi(a,b,c){var d=b.pendingProps,e=d.children,f=null!==a?a.memoizedState:null;if("hidden"===d.mode||"unstable-defer-without-hiding"===d.mode)if(0===(b.mode&4))b.memoizedState={baseLanes:0},ni(b,c);else if(0!==(c&1073741824))b.memoizedState={baseLanes:0},ni(b,null!==f?f.baseLanes:c);else return a=null!==f?f.baseLanes|c:c,b.lanes=b.childLanes=1073741824,b.memoizedState={baseLanes:a},ni(b,a),null;else null!==f?(d=f.baseLanes|c,b.memoizedState=null):d=c,ni(b,d);fi(a,b,e,c);return b.child}
|
||||
function oi(a,b){var c=b.ref;if(null===a&&null!==c||null!==a&&a.ref!==c)b.flags|=128;}function li(a,b,c,d,e){var f=Ff(c)?Df:M.current;f=Ef(b,f);tg(b,e);c=Ch(a,b,c,d,f,e);if(null!==a&&!ug)return b.updateQueue=a.updateQueue,b.flags&=-517,a.lanes&=~e,hi(a,b,e);b.flags|=1;fi(a,b,c,e);return b.child}
|
||||
function pi(a,b,c,d,e){if(Ff(c)){var f=!0;Jf(b);}else f=!1;tg(b,e);if(null===b.stateNode)null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2),Mg(b,c,d),Og(b,c,d,e),d=!0;else if(null===a){var g=b.stateNode,h=b.memoizedProps;g.props=h;var k=g.context,l=c.contextType;"object"===typeof l&&null!==l?l=vg(l):(l=Ff(c)?Df:M.current,l=Ef(b,l));var n=c.getDerivedStateFromProps,A="function"===typeof n||"function"===typeof g.getSnapshotBeforeUpdate;A||"function"!==typeof g.UNSAFE_componentWillReceiveProps&&
|
||||
"function"!==typeof g.componentWillReceiveProps||(h!==d||k!==l)&&Ng(b,g,d,l);wg=!1;var p=b.memoizedState;g.state=p;Cg(b,d,g,e);k=b.memoizedState;h!==d||p!==k||N.current||wg?("function"===typeof n&&(Gg(b,c,n,d),k=b.memoizedState),(h=wg||Lg(b,c,h,d,p,k,l))?(A||"function"!==typeof g.UNSAFE_componentWillMount&&"function"!==typeof g.componentWillMount||("function"===typeof g.componentWillMount&&g.componentWillMount(),"function"===typeof g.UNSAFE_componentWillMount&&g.UNSAFE_componentWillMount()),"function"===
|
||||
typeof g.componentDidMount&&(b.flags|=4)):("function"===typeof g.componentDidMount&&(b.flags|=4),b.memoizedProps=d,b.memoizedState=k),g.props=d,g.state=k,g.context=l,d=h):("function"===typeof g.componentDidMount&&(b.flags|=4),d=!1);}else {g=b.stateNode;yg(a,b);h=b.memoizedProps;l=b.type===b.elementType?h:lg(b.type,h);g.props=l;A=b.pendingProps;p=g.context;k=c.contextType;"object"===typeof k&&null!==k?k=vg(k):(k=Ff(c)?Df:M.current,k=Ef(b,k));var C=c.getDerivedStateFromProps;(n="function"===typeof C||
|
||||
"function"===typeof g.getSnapshotBeforeUpdate)||"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||(h!==A||p!==k)&&Ng(b,g,d,k);wg=!1;p=b.memoizedState;g.state=p;Cg(b,d,g,e);var x=b.memoizedState;h!==A||p!==x||N.current||wg?("function"===typeof C&&(Gg(b,c,C,d),x=b.memoizedState),(l=wg||Lg(b,c,l,d,p,x,k))?(n||"function"!==typeof g.UNSAFE_componentWillUpdate&&"function"!==typeof g.componentWillUpdate||("function"===typeof g.componentWillUpdate&&g.componentWillUpdate(d,
|
||||
x,k),"function"===typeof g.UNSAFE_componentWillUpdate&&g.UNSAFE_componentWillUpdate(d,x,k)),"function"===typeof g.componentDidUpdate&&(b.flags|=4),"function"===typeof g.getSnapshotBeforeUpdate&&(b.flags|=256)):("function"!==typeof g.componentDidUpdate||h===a.memoizedProps&&p===a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&p===a.memoizedState||(b.flags|=256),b.memoizedProps=d,b.memoizedState=x),g.props=d,g.state=x,g.context=k,d=l):("function"!==typeof g.componentDidUpdate||
|
||||
h===a.memoizedProps&&p===a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&p===a.memoizedState||(b.flags|=256),d=!1);}return qi(a,b,c,d,f,e)}
|
||||
function qi(a,b,c,d,e,f){oi(a,b);var g=0!==(b.flags&64);if(!d&&!g)return e&&Kf(b,c,!1),hi(a,b,f);d=b.stateNode;ei.current=b;var h=g&&"function"!==typeof c.getDerivedStateFromError?null:d.render();b.flags|=1;null!==a&&g?(b.child=Yg(b,a.child,null,f),b.child=Yg(b,null,h,f)):fi(a,b,h,f);b.memoizedState=d.state;e&&Kf(b,c,!0);return b.child}function ri(a){var b=a.stateNode;b.pendingContext?Hf(a,b.pendingContext,b.pendingContext!==b.context):b.context&&Hf(a,b.context,!1);eh(a,b.containerInfo);}
|
||||
var si={dehydrated:null,retryLane:0};
|
||||
function ti(a,b,c){var d=b.pendingProps,e=P.current,f=!1,g;(g=0!==(b.flags&64))||(g=null!==a&&null===a.memoizedState?!1:0!==(e&2));g?(f=!0,b.flags&=-65):null!==a&&null===a.memoizedState||void 0===d.fallback||!0===d.unstable_avoidThisFallback||(e|=1);I(P,e&1);if(null===a){void 0!==d.fallback&&ph(b);a=d.children;e=d.fallback;if(f)return a=ui(b,a,e,c),b.child.memoizedState={baseLanes:c},b.memoizedState=si,a;if("number"===typeof d.unstable_expectedLoadTime)return a=ui(b,a,e,c),b.child.memoizedState={baseLanes:c},
|
||||
b.memoizedState=si,b.lanes=33554432,a;c=vi({mode:"visible",children:a},b.mode,c,null);c.return=b;return b.child=c}if(null!==a.memoizedState){if(f)return d=wi(a,b,d.children,d.fallback,c),f=b.child,e=a.child.memoizedState,f.memoizedState=null===e?{baseLanes:c}:{baseLanes:e.baseLanes|c},f.childLanes=a.childLanes&~c,b.memoizedState=si,d;c=xi(a,b,d.children,c);b.memoizedState=null;return c}if(f)return d=wi(a,b,d.children,d.fallback,c),f=b.child,e=a.child.memoizedState,f.memoizedState=null===e?{baseLanes:c}:
|
||||
{baseLanes:e.baseLanes|c},f.childLanes=a.childLanes&~c,b.memoizedState=si,d;c=xi(a,b,d.children,c);b.memoizedState=null;return c}function ui(a,b,c,d){var e=a.mode,f=a.child;b={mode:"hidden",children:b};0===(e&2)&&null!==f?(f.childLanes=0,f.pendingProps=b):f=vi(b,e,0,null);c=Xg(c,e,d,null);f.return=a;c.return=a;f.sibling=c;a.child=f;return c}
|
||||
function xi(a,b,c,d){var e=a.child;a=e.sibling;c=Tg(e,{mode:"visible",children:c});0===(b.mode&2)&&(c.lanes=d);c.return=b;c.sibling=null;null!==a&&(a.nextEffect=null,a.flags=8,b.firstEffect=b.lastEffect=a);return b.child=c}
|
||||
function wi(a,b,c,d,e){var f=b.mode,g=a.child;a=g.sibling;var h={mode:"hidden",children:c};0===(f&2)&&b.child!==g?(c=b.child,c.childLanes=0,c.pendingProps=h,g=c.lastEffect,null!==g?(b.firstEffect=c.firstEffect,b.lastEffect=g,g.nextEffect=null):b.firstEffect=b.lastEffect=null):c=Tg(g,h);null!==a?d=Tg(a,d):(d=Xg(d,f,e,null),d.flags|=2);d.return=b;c.return=b;c.sibling=d;b.child=c;return d}function yi(a,b){a.lanes|=b;var c=a.alternate;null!==c&&(c.lanes|=b);sg(a.return,b);}
|
||||
function zi(a,b,c,d,e,f){var g=a.memoizedState;null===g?a.memoizedState={isBackwards:b,rendering:null,renderingStartTime:0,last:d,tail:c,tailMode:e,lastEffect:f}:(g.isBackwards=b,g.rendering=null,g.renderingStartTime=0,g.last=d,g.tail=c,g.tailMode=e,g.lastEffect=f);}
|
||||
function Ai(a,b,c){var d=b.pendingProps,e=d.revealOrder,f=d.tail;fi(a,b,d.children,c);d=P.current;if(0!==(d&2))d=d&1|2,b.flags|=64;else {if(null!==a&&0!==(a.flags&64))a:for(a=b.child;null!==a;){if(13===a.tag)null!==a.memoizedState&&yi(a,c);else if(19===a.tag)yi(a,c);else if(null!==a.child){a.child.return=a;a=a.child;continue}if(a===b)break a;for(;null===a.sibling;){if(null===a.return||a.return===b)break a;a=a.return;}a.sibling.return=a.return;a=a.sibling;}d&=1;}I(P,d);if(0===(b.mode&2))b.memoizedState=
|
||||
null;else switch(e){case "forwards":c=b.child;for(e=null;null!==c;)a=c.alternate,null!==a&&null===ih(a)&&(e=c),c=c.sibling;c=e;null===c?(e=b.child,b.child=null):(e=c.sibling,c.sibling=null);zi(b,!1,e,c,f,b.lastEffect);break;case "backwards":c=null;e=b.child;for(b.child=null;null!==e;){a=e.alternate;if(null!==a&&null===ih(a)){b.child=e;break}a=e.sibling;e.sibling=c;c=e;e=a;}zi(b,!0,c,null,f,b.lastEffect);break;case "together":zi(b,!1,null,null,void 0,b.lastEffect);break;default:b.memoizedState=null;}return b.child}
|
||||
function hi(a,b,c){null!==a&&(b.dependencies=a.dependencies);Dg|=b.lanes;if(0!==(c&b.childLanes)){if(null!==a&&b.child!==a.child)throw Error(y(153));if(null!==b.child){a=b.child;c=Tg(a,a.pendingProps);b.child=c;for(c.return=b;null!==a.sibling;)a=a.sibling,c=c.sibling=Tg(a,a.pendingProps),c.return=b;c.sibling=null;}return b.child}return null}var Bi,Ci,Di,Ei;
|
||||
Bi=function(a,b){for(var c=b.child;null!==c;){if(5===c.tag||6===c.tag)a.appendChild(c.stateNode);else if(4!==c.tag&&null!==c.child){c.child.return=c;c=c.child;continue}if(c===b)break;for(;null===c.sibling;){if(null===c.return||c.return===b)return;c=c.return;}c.sibling.return=c.return;c=c.sibling;}};Ci=function(){};
|
||||
Di=function(a,b,c,d){var e=a.memoizedProps;if(e!==d){a=b.stateNode;dh(ah.current);var f=null;switch(c){case "input":e=Ya(a,e);d=Ya(a,d);f=[];break;case "option":e=eb(a,e);d=eb(a,d);f=[];break;case "select":e=objectAssign({},e,{value:void 0});d=objectAssign({},d,{value:void 0});f=[];break;case "textarea":e=gb(a,e);d=gb(a,d);f=[];break;default:"function"!==typeof e.onClick&&"function"===typeof d.onClick&&(a.onclick=jf);}vb(c,d);var g;c=null;for(l in e)if(!d.hasOwnProperty(l)&&e.hasOwnProperty(l)&&null!=e[l])if("style"===
|
||||
l){var h=e[l];for(g in h)h.hasOwnProperty(g)&&(c||(c={}),c[g]="");}else "dangerouslySetInnerHTML"!==l&&"children"!==l&&"suppressContentEditableWarning"!==l&&"suppressHydrationWarning"!==l&&"autoFocus"!==l&&(ca.hasOwnProperty(l)?f||(f=[]):(f=f||[]).push(l,null));for(l in d){var k=d[l];h=null!=e?e[l]:void 0;if(d.hasOwnProperty(l)&&k!==h&&(null!=k||null!=h))if("style"===l)if(h){for(g in h)!h.hasOwnProperty(g)||k&&k.hasOwnProperty(g)||(c||(c={}),c[g]="");for(g in k)k.hasOwnProperty(g)&&h[g]!==k[g]&&(c||
|
||||
(c={}),c[g]=k[g]);}else c||(f||(f=[]),f.push(l,c)),c=k;else "dangerouslySetInnerHTML"===l?(k=k?k.__html:void 0,h=h?h.__html:void 0,null!=k&&h!==k&&(f=f||[]).push(l,k)):"children"===l?"string"!==typeof k&&"number"!==typeof k||(f=f||[]).push(l,""+k):"suppressContentEditableWarning"!==l&&"suppressHydrationWarning"!==l&&(ca.hasOwnProperty(l)?(null!=k&&"onScroll"===l&&G("scroll",a),f||h===k||(f=[])):"object"===typeof k&&null!==k&&k.$$typeof===Ga?k.toString():(f=f||[]).push(l,k));}c&&(f=f||[]).push("style",
|
||||
c);var l=f;if(b.updateQueue=l)b.flags|=4;}};Ei=function(a,b,c,d){c!==d&&(b.flags|=4);};function Fi(a,b){if(!lh)switch(a.tailMode){case "hidden":b=a.tail;for(var c=null;null!==b;)null!==b.alternate&&(c=b),b=b.sibling;null===c?a.tail=null:c.sibling=null;break;case "collapsed":c=a.tail;for(var d=null;null!==c;)null!==c.alternate&&(d=c),c=c.sibling;null===d?b||null===a.tail?a.tail=null:a.tail.sibling=null:d.sibling=null;}}
|
||||
function Gi(a,b,c){var d=b.pendingProps;switch(b.tag){case 2:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return null;case 1:return Ff(b.type)&&Gf(),null;case 3:fh();H(N);H(M);uh();d=b.stateNode;d.pendingContext&&(d.context=d.pendingContext,d.pendingContext=null);if(null===a||null===a.child)rh(b)?b.flags|=4:d.hydrate||(b.flags|=256);Ci(b);return null;case 5:hh(b);var e=dh(ch.current);c=b.type;if(null!==a&&null!=b.stateNode)Di(a,b,c,d,e),a.ref!==b.ref&&(b.flags|=128);else {if(!d){if(null===
|
||||
b.stateNode)throw Error(y(166));return null}a=dh(ah.current);if(rh(b)){d=b.stateNode;c=b.type;var f=b.memoizedProps;d[wf]=b;d[xf]=f;switch(c){case "dialog":G("cancel",d);G("close",d);break;case "iframe":case "object":case "embed":G("load",d);break;case "video":case "audio":for(a=0;a<Xe.length;a++)G(Xe[a],d);break;case "source":G("error",d);break;case "img":case "image":case "link":G("error",d);G("load",d);break;case "details":G("toggle",d);break;case "input":Za(d,f);G("invalid",d);break;case "select":d._wrapperState=
|
||||
{wasMultiple:!!f.multiple};G("invalid",d);break;case "textarea":hb(d,f),G("invalid",d);}vb(c,f);a=null;for(var g in f)f.hasOwnProperty(g)&&(e=f[g],"children"===g?"string"===typeof e?d.textContent!==e&&(a=["children",e]):"number"===typeof e&&d.textContent!==""+e&&(a=["children",""+e]):ca.hasOwnProperty(g)&&null!=e&&"onScroll"===g&&G("scroll",d));switch(c){case "input":Va(d);cb(d,f,!0);break;case "textarea":Va(d);jb(d);break;case "select":case "option":break;default:"function"===typeof f.onClick&&(d.onclick=
|
||||
jf);}d=a;b.updateQueue=d;null!==d&&(b.flags|=4);}else {g=9===e.nodeType?e:e.ownerDocument;a===kb.html&&(a=lb(c));a===kb.html?"script"===c?(a=g.createElement("div"),a.innerHTML="<script>\x3c/script>",a=a.removeChild(a.firstChild)):"string"===typeof d.is?a=g.createElement(c,{is:d.is}):(a=g.createElement(c),"select"===c&&(g=a,d.multiple?g.multiple=!0:d.size&&(g.size=d.size))):a=g.createElementNS(a,c);a[wf]=b;a[xf]=d;Bi(a,b,!1,!1);b.stateNode=a;g=wb(c,d);switch(c){case "dialog":G("cancel",a);G("close",a);
|
||||
e=d;break;case "iframe":case "object":case "embed":G("load",a);e=d;break;case "video":case "audio":for(e=0;e<Xe.length;e++)G(Xe[e],a);e=d;break;case "source":G("error",a);e=d;break;case "img":case "image":case "link":G("error",a);G("load",a);e=d;break;case "details":G("toggle",a);e=d;break;case "input":Za(a,d);e=Ya(a,d);G("invalid",a);break;case "option":e=eb(a,d);break;case "select":a._wrapperState={wasMultiple:!!d.multiple};e=objectAssign({},d,{value:void 0});G("invalid",a);break;case "textarea":hb(a,d);e=
|
||||
gb(a,d);G("invalid",a);break;default:e=d;}vb(c,e);var h=e;for(f in h)if(h.hasOwnProperty(f)){var k=h[f];"style"===f?tb(a,k):"dangerouslySetInnerHTML"===f?(k=k?k.__html:void 0,null!=k&&ob(a,k)):"children"===f?"string"===typeof k?("textarea"!==c||""!==k)&&pb(a,k):"number"===typeof k&&pb(a,""+k):"suppressContentEditableWarning"!==f&&"suppressHydrationWarning"!==f&&"autoFocus"!==f&&(ca.hasOwnProperty(f)?null!=k&&"onScroll"===f&&G("scroll",a):null!=k&&qa(a,f,k,g));}switch(c){case "input":Va(a);cb(a,d,!1);
|
||||
break;case "textarea":Va(a);jb(a);break;case "option":null!=d.value&&a.setAttribute("value",""+Sa(d.value));break;case "select":a.multiple=!!d.multiple;f=d.value;null!=f?fb(a,!!d.multiple,f,!1):null!=d.defaultValue&&fb(a,!!d.multiple,d.defaultValue,!0);break;default:"function"===typeof e.onClick&&(a.onclick=jf);}mf(c,d)&&(b.flags|=4);}null!==b.ref&&(b.flags|=128);}return null;case 6:if(a&&null!=b.stateNode)Ei(a,b,a.memoizedProps,d);else {if("string"!==typeof d&&null===b.stateNode)throw Error(y(166));
|
||||
c=dh(ch.current);dh(ah.current);rh(b)?(d=b.stateNode,c=b.memoizedProps,d[wf]=b,d.nodeValue!==c&&(b.flags|=4)):(d=(9===c.nodeType?c:c.ownerDocument).createTextNode(d),d[wf]=b,b.stateNode=d);}return null;case 13:H(P);d=b.memoizedState;if(0!==(b.flags&64))return b.lanes=c,b;d=null!==d;c=!1;null===a?void 0!==b.memoizedProps.fallback&&rh(b):c=null!==a.memoizedState;if(d&&!c&&0!==(b.mode&2))if(null===a&&!0!==b.memoizedProps.unstable_avoidThisFallback||0!==(P.current&1))0===V&&(V=3);else {if(0===V||3===V)V=
|
||||
4;null===U||0===(Dg&134217727)&&0===(Hi&134217727)||Ii(U,W);}if(d||c)b.flags|=4;return null;case 4:return fh(),Ci(b),null===a&&cf(b.stateNode.containerInfo),null;case 10:return rg(b),null;case 17:return Ff(b.type)&&Gf(),null;case 19:H(P);d=b.memoizedState;if(null===d)return null;f=0!==(b.flags&64);g=d.rendering;if(null===g)if(f)Fi(d,!1);else {if(0!==V||null!==a&&0!==(a.flags&64))for(a=b.child;null!==a;){g=ih(a);if(null!==g){b.flags|=64;Fi(d,!1);f=g.updateQueue;null!==f&&(b.updateQueue=f,b.flags|=4);
|
||||
null===d.lastEffect&&(b.firstEffect=null);b.lastEffect=d.lastEffect;d=c;for(c=b.child;null!==c;)f=c,a=d,f.flags&=2,f.nextEffect=null,f.firstEffect=null,f.lastEffect=null,g=f.alternate,null===g?(f.childLanes=0,f.lanes=a,f.child=null,f.memoizedProps=null,f.memoizedState=null,f.updateQueue=null,f.dependencies=null,f.stateNode=null):(f.childLanes=g.childLanes,f.lanes=g.lanes,f.child=g.child,f.memoizedProps=g.memoizedProps,f.memoizedState=g.memoizedState,f.updateQueue=g.updateQueue,f.type=g.type,a=g.dependencies,
|
||||
f.dependencies=null===a?null:{lanes:a.lanes,firstContext:a.firstContext}),c=c.sibling;I(P,P.current&1|2);return b.child}a=a.sibling;}null!==d.tail&&O()>Ji&&(b.flags|=64,f=!0,Fi(d,!1),b.lanes=33554432);}else {if(!f)if(a=ih(g),null!==a){if(b.flags|=64,f=!0,c=a.updateQueue,null!==c&&(b.updateQueue=c,b.flags|=4),Fi(d,!0),null===d.tail&&"hidden"===d.tailMode&&!g.alternate&&!lh)return b=b.lastEffect=d.lastEffect,null!==b&&(b.nextEffect=null),null}else 2*O()-d.renderingStartTime>Ji&&1073741824!==c&&(b.flags|=
|
||||
64,f=!0,Fi(d,!1),b.lanes=33554432);d.isBackwards?(g.sibling=b.child,b.child=g):(c=d.last,null!==c?c.sibling=g:b.child=g,d.last=g);}return null!==d.tail?(c=d.tail,d.rendering=c,d.tail=c.sibling,d.lastEffect=b.lastEffect,d.renderingStartTime=O(),c.sibling=null,b=P.current,I(P,f?b&1|2:b&1),c):null;case 23:case 24:return Ki(),null!==a&&null!==a.memoizedState!==(null!==b.memoizedState)&&"unstable-defer-without-hiding"!==d.mode&&(b.flags|=4),null}throw Error(y(156,b.tag));}
|
||||
function Li(a){switch(a.tag){case 1:Ff(a.type)&&Gf();var b=a.flags;return b&4096?(a.flags=b&-4097|64,a):null;case 3:fh();H(N);H(M);uh();b=a.flags;if(0!==(b&64))throw Error(y(285));a.flags=b&-4097|64;return a;case 5:return hh(a),null;case 13:return H(P),b=a.flags,b&4096?(a.flags=b&-4097|64,a):null;case 19:return H(P),null;case 4:return fh(),null;case 10:return rg(a),null;case 23:case 24:return Ki(),null;default:return null}}
|
||||
function Mi(a,b){try{var c="",d=b;do c+=Qa(d),d=d.return;while(d);var e=c;}catch(f){e="\nError generating stack: "+f.message+"\n"+f.stack;}return {value:a,source:b,stack:e}}function Ni(a,b){try{console.error(b.value);}catch(c){setTimeout(function(){throw c;});}}var Oi="function"===typeof WeakMap?WeakMap:Map;function Pi(a,b,c){c=zg(-1,c);c.tag=3;c.payload={element:null};var d=b.value;c.callback=function(){Qi||(Qi=!0,Ri=d);Ni(a,b);};return c}
|
||||
function Si(a,b,c){c=zg(-1,c);c.tag=3;var d=a.type.getDerivedStateFromError;if("function"===typeof d){var e=b.value;c.payload=function(){Ni(a,b);return d(e)};}var f=a.stateNode;null!==f&&"function"===typeof f.componentDidCatch&&(c.callback=function(){"function"!==typeof d&&(null===Ti?Ti=new Set([this]):Ti.add(this),Ni(a,b));var c=b.stack;this.componentDidCatch(b.value,{componentStack:null!==c?c:""});});return c}var Ui="function"===typeof WeakSet?WeakSet:Set;
|
||||
function Vi(a){var b=a.ref;if(null!==b)if("function"===typeof b)try{b(null);}catch(c){Wi(a,c);}else b.current=null;}function Xi(a,b){switch(b.tag){case 0:case 11:case 15:case 22:return;case 1:if(b.flags&256&&null!==a){var c=a.memoizedProps,d=a.memoizedState;a=b.stateNode;b=a.getSnapshotBeforeUpdate(b.elementType===b.type?c:lg(b.type,c),d);a.__reactInternalSnapshotBeforeUpdate=b;}return;case 3:b.flags&256&&qf(b.stateNode.containerInfo);return;case 5:case 6:case 4:case 17:return}throw Error(y(163));}
|
||||
function Yi(a,b,c){switch(c.tag){case 0:case 11:case 15:case 22:b=c.updateQueue;b=null!==b?b.lastEffect:null;if(null!==b){a=b=b.next;do{if(3===(a.tag&3)){var d=a.create;a.destroy=d();}a=a.next;}while(a!==b)}b=c.updateQueue;b=null!==b?b.lastEffect:null;if(null!==b){a=b=b.next;do{var e=a;d=e.next;e=e.tag;0!==(e&4)&&0!==(e&1)&&(Zi(c,a),$i(c,a));a=d;}while(a!==b)}return;case 1:a=c.stateNode;c.flags&4&&(null===b?a.componentDidMount():(d=c.elementType===c.type?b.memoizedProps:lg(c.type,b.memoizedProps),a.componentDidUpdate(d,
|
||||
b.memoizedState,a.__reactInternalSnapshotBeforeUpdate)));b=c.updateQueue;null!==b&&Eg(c,b,a);return;case 3:b=c.updateQueue;if(null!==b){a=null;if(null!==c.child)switch(c.child.tag){case 5:a=c.child.stateNode;break;case 1:a=c.child.stateNode;}Eg(c,b,a);}return;case 5:a=c.stateNode;null===b&&c.flags&4&&mf(c.type,c.memoizedProps)&&a.focus();return;case 6:return;case 4:return;case 12:return;case 13:null===c.memoizedState&&(c=c.alternate,null!==c&&(c=c.memoizedState,null!==c&&(c=c.dehydrated,null!==c&&Cc(c))));
|
||||
return;case 19:case 17:case 20:case 21:case 23:case 24:return}throw Error(y(163));}
|
||||
function aj(a,b){for(var c=a;;){if(5===c.tag){var d=c.stateNode;if(b)d=d.style,"function"===typeof d.setProperty?d.setProperty("display","none","important"):d.display="none";else {d=c.stateNode;var e=c.memoizedProps.style;e=void 0!==e&&null!==e&&e.hasOwnProperty("display")?e.display:null;d.style.display=sb("display",e);}}else if(6===c.tag)c.stateNode.nodeValue=b?"":c.memoizedProps;else if((23!==c.tag&&24!==c.tag||null===c.memoizedState||c===a)&&null!==c.child){c.child.return=c;c=c.child;continue}if(c===
|
||||
a)break;for(;null===c.sibling;){if(null===c.return||c.return===a)return;c=c.return;}c.sibling.return=c.return;c=c.sibling;}}
|
||||
function bj(a,b){if(Mf&&"function"===typeof Mf.onCommitFiberUnmount)try{Mf.onCommitFiberUnmount(Lf,b);}catch(f){}switch(b.tag){case 0:case 11:case 14:case 15:case 22:a=b.updateQueue;if(null!==a&&(a=a.lastEffect,null!==a)){var c=a=a.next;do{var d=c,e=d.destroy;d=d.tag;if(void 0!==e)if(0!==(d&4))Zi(b,c);else {d=b;try{e();}catch(f){Wi(d,f);}}c=c.next;}while(c!==a)}break;case 1:Vi(b);a=b.stateNode;if("function"===typeof a.componentWillUnmount)try{a.props=b.memoizedProps,a.state=b.memoizedState,a.componentWillUnmount();}catch(f){Wi(b,
|
||||
f);}break;case 5:Vi(b);break;case 4:cj(a,b);}}function dj(a){a.alternate=null;a.child=null;a.dependencies=null;a.firstEffect=null;a.lastEffect=null;a.memoizedProps=null;a.memoizedState=null;a.pendingProps=null;a.return=null;a.updateQueue=null;}function ej(a){return 5===a.tag||3===a.tag||4===a.tag}
|
||||
function fj(a){a:{for(var b=a.return;null!==b;){if(ej(b))break a;b=b.return;}throw Error(y(160));}var c=b;b=c.stateNode;switch(c.tag){case 5:var d=!1;break;case 3:b=b.containerInfo;d=!0;break;case 4:b=b.containerInfo;d=!0;break;default:throw Error(y(161));}c.flags&16&&(pb(b,""),c.flags&=-17);a:b:for(c=a;;){for(;null===c.sibling;){if(null===c.return||ej(c.return)){c=null;break a}c=c.return;}c.sibling.return=c.return;for(c=c.sibling;5!==c.tag&&6!==c.tag&&18!==c.tag;){if(c.flags&2)continue b;if(null===
|
||||
c.child||4===c.tag)continue b;else c.child.return=c,c=c.child;}if(!(c.flags&2)){c=c.stateNode;break a}}d?gj(a,c,b):hj(a,c,b);}
|
||||
function gj(a,b,c){var d=a.tag,e=5===d||6===d;if(e)a=e?a.stateNode:a.stateNode.instance,b?8===c.nodeType?c.parentNode.insertBefore(a,b):c.insertBefore(a,b):(8===c.nodeType?(b=c.parentNode,b.insertBefore(a,c)):(b=c,b.appendChild(a)),c=c._reactRootContainer,null!==c&&void 0!==c||null!==b.onclick||(b.onclick=jf));else if(4!==d&&(a=a.child,null!==a))for(gj(a,b,c),a=a.sibling;null!==a;)gj(a,b,c),a=a.sibling;}
|
||||
function hj(a,b,c){var d=a.tag,e=5===d||6===d;if(e)a=e?a.stateNode:a.stateNode.instance,b?c.insertBefore(a,b):c.appendChild(a);else if(4!==d&&(a=a.child,null!==a))for(hj(a,b,c),a=a.sibling;null!==a;)hj(a,b,c),a=a.sibling;}
|
||||
function cj(a,b){for(var c=b,d=!1,e,f;;){if(!d){d=c.return;a:for(;;){if(null===d)throw Error(y(160));e=d.stateNode;switch(d.tag){case 5:f=!1;break a;case 3:e=e.containerInfo;f=!0;break a;case 4:e=e.containerInfo;f=!0;break a}d=d.return;}d=!0;}if(5===c.tag||6===c.tag){a:for(var g=a,h=c,k=h;;)if(bj(g,k),null!==k.child&&4!==k.tag)k.child.return=k,k=k.child;else {if(k===h)break a;for(;null===k.sibling;){if(null===k.return||k.return===h)break a;k=k.return;}k.sibling.return=k.return;k=k.sibling;}f?(g=e,h=c.stateNode,
|
||||
8===g.nodeType?g.parentNode.removeChild(h):g.removeChild(h)):e.removeChild(c.stateNode);}else if(4===c.tag){if(null!==c.child){e=c.stateNode.containerInfo;f=!0;c.child.return=c;c=c.child;continue}}else if(bj(a,c),null!==c.child){c.child.return=c;c=c.child;continue}if(c===b)break;for(;null===c.sibling;){if(null===c.return||c.return===b)return;c=c.return;4===c.tag&&(d=!1);}c.sibling.return=c.return;c=c.sibling;}}
|
||||
function ij(a,b){switch(b.tag){case 0:case 11:case 14:case 15:case 22:var c=b.updateQueue;c=null!==c?c.lastEffect:null;if(null!==c){var d=c=c.next;do 3===(d.tag&3)&&(a=d.destroy,d.destroy=void 0,void 0!==a&&a()),d=d.next;while(d!==c)}return;case 1:return;case 5:c=b.stateNode;if(null!=c){d=b.memoizedProps;var e=null!==a?a.memoizedProps:d;a=b.type;var f=b.updateQueue;b.updateQueue=null;if(null!==f){c[xf]=d;"input"===a&&"radio"===d.type&&null!=d.name&&$a(c,d);wb(a,e);b=wb(a,d);for(e=0;e<f.length;e+=
|
||||
2){var g=f[e],h=f[e+1];"style"===g?tb(c,h):"dangerouslySetInnerHTML"===g?ob(c,h):"children"===g?pb(c,h):qa(c,g,h,b);}switch(a){case "input":ab(c,d);break;case "textarea":ib(c,d);break;case "select":a=c._wrapperState.wasMultiple,c._wrapperState.wasMultiple=!!d.multiple,f=d.value,null!=f?fb(c,!!d.multiple,f,!1):a!==!!d.multiple&&(null!=d.defaultValue?fb(c,!!d.multiple,d.defaultValue,!0):fb(c,!!d.multiple,d.multiple?[]:"",!1));}}}return;case 6:if(null===b.stateNode)throw Error(y(162));b.stateNode.nodeValue=
|
||||
b.memoizedProps;return;case 3:c=b.stateNode;c.hydrate&&(c.hydrate=!1,Cc(c.containerInfo));return;case 12:return;case 13:null!==b.memoizedState&&(jj=O(),aj(b.child,!0));kj(b);return;case 19:kj(b);return;case 17:return;case 23:case 24:aj(b,null!==b.memoizedState);return}throw Error(y(163));}function kj(a){var b=a.updateQueue;if(null!==b){a.updateQueue=null;var c=a.stateNode;null===c&&(c=a.stateNode=new Ui);b.forEach(function(b){var d=lj.bind(null,a,b);c.has(b)||(c.add(b),b.then(d,d));});}}
|
||||
function mj(a,b){return null!==a&&(a=a.memoizedState,null===a||null!==a.dehydrated)?(b=b.memoizedState,null!==b&&null===b.dehydrated):!1}var nj=Math.ceil,oj=ra.ReactCurrentDispatcher,pj=ra.ReactCurrentOwner,X=0,U=null,Y=null,W=0,qj=0,rj=Bf(0),V=0,sj=null,tj=0,Dg=0,Hi=0,uj=0,vj=null,jj=0,Ji=Infinity;function wj(){Ji=O()+500;}var Z=null,Qi=!1,Ri=null,Ti=null,xj=!1,yj=null,zj=90,Aj=[],Bj=[],Cj=null,Dj=0,Ej=null,Fj=-1,Gj=0,Hj=0,Ij=null,Jj=!1;function Hg(){return 0!==(X&48)?O():-1!==Fj?Fj:Fj=O()}
|
||||
function Ig(a){a=a.mode;if(0===(a&2))return 1;if(0===(a&4))return 99===eg()?1:2;0===Gj&&(Gj=tj);if(0!==kg.transition){0!==Hj&&(Hj=null!==vj?vj.pendingLanes:0);a=Gj;var b=4186112&~Hj;b&=-b;0===b&&(a=4186112&~a,b=a&-a,0===b&&(b=8192));return b}a=eg();0!==(X&4)&&98===a?a=Xc(12,Gj):(a=Sc(a),a=Xc(a,Gj));return a}
|
||||
function Jg(a,b,c){if(50<Dj)throw Dj=0,Ej=null,Error(y(185));a=Kj(a,b);if(null===a)return null;$c(a,b,c);a===U&&(Hi|=b,4===V&&Ii(a,W));var d=eg();1===b?0!==(X&8)&&0===(X&48)?Lj(a):(Mj(a,c),0===X&&(wj(),ig())):(0===(X&4)||98!==d&&99!==d||(null===Cj?Cj=new Set([a]):Cj.add(a)),Mj(a,c));vj=a;}function Kj(a,b){a.lanes|=b;var c=a.alternate;null!==c&&(c.lanes|=b);c=a;for(a=a.return;null!==a;)a.childLanes|=b,c=a.alternate,null!==c&&(c.childLanes|=b),c=a,a=a.return;return 3===c.tag?c.stateNode:null}
|
||||
function Mj(a,b){for(var c=a.callbackNode,d=a.suspendedLanes,e=a.pingedLanes,f=a.expirationTimes,g=a.pendingLanes;0<g;){var h=31-Vc(g),k=1<<h,l=f[h];if(-1===l){if(0===(k&d)||0!==(k&e)){l=b;Rc(k);var n=F;f[h]=10<=n?l+250:6<=n?l+5E3:-1;}}else l<=b&&(a.expiredLanes|=k);g&=~k;}d=Uc(a,a===U?W:0);b=F;if(0===d)null!==c&&(c!==Zf&&Pf(c),a.callbackNode=null,a.callbackPriority=0);else {if(null!==c){if(a.callbackPriority===b)return;c!==Zf&&Pf(c);}15===b?(c=Lj.bind(null,a),null===ag?(ag=[c],bg=Of(Uf,jg)):ag.push(c),
|
||||
c=Zf):14===b?c=hg(99,Lj.bind(null,a)):(c=Tc(b),c=hg(c,Nj.bind(null,a)));a.callbackPriority=b;a.callbackNode=c;}}
|
||||
function Nj(a){Fj=-1;Hj=Gj=0;if(0!==(X&48))throw Error(y(327));var b=a.callbackNode;if(Oj()&&a.callbackNode!==b)return null;var c=Uc(a,a===U?W:0);if(0===c)return null;var d=c;var e=X;X|=16;var f=Pj();if(U!==a||W!==d)wj(),Qj(a,d);do try{Rj();break}catch(h){Sj(a,h);}while(1);qg();oj.current=f;X=e;null!==Y?d=0:(U=null,W=0,d=V);if(0!==(tj&Hi))Qj(a,0);else if(0!==d){2===d&&(X|=64,a.hydrate&&(a.hydrate=!1,qf(a.containerInfo)),c=Wc(a),0!==c&&(d=Tj(a,c)));if(1===d)throw b=sj,Qj(a,0),Ii(a,c),Mj(a,O()),b;a.finishedWork=
|
||||
a.current.alternate;a.finishedLanes=c;switch(d){case 0:case 1:throw Error(y(345));case 2:Uj(a);break;case 3:Ii(a,c);if((c&62914560)===c&&(d=jj+500-O(),10<d)){if(0!==Uc(a,0))break;e=a.suspendedLanes;if((e&c)!==c){Hg();a.pingedLanes|=a.suspendedLanes&e;break}a.timeoutHandle=of(Uj.bind(null,a),d);break}Uj(a);break;case 4:Ii(a,c);if((c&4186112)===c)break;d=a.eventTimes;for(e=-1;0<c;){var g=31-Vc(c);f=1<<g;g=d[g];g>e&&(e=g);c&=~f;}c=e;c=O()-c;c=(120>c?120:480>c?480:1080>c?1080:1920>c?1920:3E3>c?3E3:4320>
|
||||
c?4320:1960*nj(c/1960))-c;if(10<c){a.timeoutHandle=of(Uj.bind(null,a),c);break}Uj(a);break;case 5:Uj(a);break;default:throw Error(y(329));}}Mj(a,O());return a.callbackNode===b?Nj.bind(null,a):null}function Ii(a,b){b&=~uj;b&=~Hi;a.suspendedLanes|=b;a.pingedLanes&=~b;for(a=a.expirationTimes;0<b;){var c=31-Vc(b),d=1<<c;a[c]=-1;b&=~d;}}
|
||||
function Lj(a){if(0!==(X&48))throw Error(y(327));Oj();if(a===U&&0!==(a.expiredLanes&W)){var b=W;var c=Tj(a,b);0!==(tj&Hi)&&(b=Uc(a,b),c=Tj(a,b));}else b=Uc(a,0),c=Tj(a,b);0!==a.tag&&2===c&&(X|=64,a.hydrate&&(a.hydrate=!1,qf(a.containerInfo)),b=Wc(a),0!==b&&(c=Tj(a,b)));if(1===c)throw c=sj,Qj(a,0),Ii(a,b),Mj(a,O()),c;a.finishedWork=a.current.alternate;a.finishedLanes=b;Uj(a);Mj(a,O());return null}
|
||||
function Vj(){if(null!==Cj){var a=Cj;Cj=null;a.forEach(function(a){a.expiredLanes|=24&a.pendingLanes;Mj(a,O());});}ig();}function Wj(a,b){var c=X;X|=1;try{return a(b)}finally{X=c,0===X&&(wj(),ig());}}function Xj(a,b){var c=X;X&=-2;X|=8;try{return a(b)}finally{X=c,0===X&&(wj(),ig());}}function ni(a,b){I(rj,qj);qj|=b;tj|=b;}function Ki(){qj=rj.current;H(rj);}
|
||||
function Qj(a,b){a.finishedWork=null;a.finishedLanes=0;var c=a.timeoutHandle;-1!==c&&(a.timeoutHandle=-1,pf(c));if(null!==Y)for(c=Y.return;null!==c;){var d=c;switch(d.tag){case 1:d=d.type.childContextTypes;null!==d&&void 0!==d&&Gf();break;case 3:fh();H(N);H(M);uh();break;case 5:hh(d);break;case 4:fh();break;case 13:H(P);break;case 19:H(P);break;case 10:rg(d);break;case 23:case 24:Ki();}c=c.return;}U=a;Y=Tg(a.current,null);W=qj=tj=b;V=0;sj=null;uj=Hi=Dg=0;}
|
||||
function Sj(a,b){do{var c=Y;try{qg();vh.current=Gh;if(yh){for(var d=R.memoizedState;null!==d;){var e=d.queue;null!==e&&(e.pending=null);d=d.next;}yh=!1;}xh=0;T=S=R=null;zh=!1;pj.current=null;if(null===c||null===c.return){V=1;sj=b;Y=null;break}a:{var f=a,g=c.return,h=c,k=b;b=W;h.flags|=2048;h.firstEffect=h.lastEffect=null;if(null!==k&&"object"===typeof k&&"function"===typeof k.then){var l=k;if(0===(h.mode&2)){var n=h.alternate;n?(h.updateQueue=n.updateQueue,h.memoizedState=n.memoizedState,h.lanes=n.lanes):
|
||||
(h.updateQueue=null,h.memoizedState=null);}var A=0!==(P.current&1),p=g;do{var C;if(C=13===p.tag){var x=p.memoizedState;if(null!==x)C=null!==x.dehydrated?!0:!1;else {var w=p.memoizedProps;C=void 0===w.fallback?!1:!0!==w.unstable_avoidThisFallback?!0:A?!1:!0;}}if(C){var z=p.updateQueue;if(null===z){var u=new Set;u.add(l);p.updateQueue=u;}else z.add(l);if(0===(p.mode&2)){p.flags|=64;h.flags|=16384;h.flags&=-2981;if(1===h.tag)if(null===h.alternate)h.tag=17;else {var t=zg(-1,1);t.tag=2;Ag(h,t);}h.lanes|=1;break a}k=
|
||||
void 0;h=b;var q=f.pingCache;null===q?(q=f.pingCache=new Oi,k=new Set,q.set(l,k)):(k=q.get(l),void 0===k&&(k=new Set,q.set(l,k)));if(!k.has(h)){k.add(h);var v=Yj.bind(null,f,l,h);l.then(v,v);}p.flags|=4096;p.lanes=b;break a}p=p.return;}while(null!==p);k=Error((Ra(h.type)||"A React component")+" suspended while rendering, but no fallback UI was specified.\n\nAdd a <Suspense fallback=...> component higher in the tree to provide a loading indicator or placeholder to display.");}5!==V&&(V=2);k=Mi(k,h);p=
|
||||
g;do{switch(p.tag){case 3:f=k;p.flags|=4096;b&=-b;p.lanes|=b;var J=Pi(p,f,b);Bg(p,J);break a;case 1:f=k;var K=p.type,Q=p.stateNode;if(0===(p.flags&64)&&("function"===typeof K.getDerivedStateFromError||null!==Q&&"function"===typeof Q.componentDidCatch&&(null===Ti||!Ti.has(Q)))){p.flags|=4096;b&=-b;p.lanes|=b;var L=Si(p,f,b);Bg(p,L);break a}}p=p.return;}while(null!==p)}Zj(c);}catch(va){b=va;Y===c&&null!==c&&(Y=c=c.return);continue}break}while(1)}
|
||||
function Pj(){var a=oj.current;oj.current=Gh;return null===a?Gh:a}function Tj(a,b){var c=X;X|=16;var d=Pj();U===a&&W===b||Qj(a,b);do try{ak();break}catch(e){Sj(a,e);}while(1);qg();X=c;oj.current=d;if(null!==Y)throw Error(y(261));U=null;W=0;return V}function ak(){for(;null!==Y;)bk(Y);}function Rj(){for(;null!==Y&&!Qf();)bk(Y);}function bk(a){var b=ck(a.alternate,a,qj);a.memoizedProps=a.pendingProps;null===b?Zj(a):Y=b;pj.current=null;}
|
||||
function Zj(a){var b=a;do{var c=b.alternate;a=b.return;if(0===(b.flags&2048)){c=Gi(c,b,qj);if(null!==c){Y=c;return}c=b;if(24!==c.tag&&23!==c.tag||null===c.memoizedState||0!==(qj&1073741824)||0===(c.mode&4)){for(var d=0,e=c.child;null!==e;)d|=e.lanes|e.childLanes,e=e.sibling;c.childLanes=d;}null!==a&&0===(a.flags&2048)&&(null===a.firstEffect&&(a.firstEffect=b.firstEffect),null!==b.lastEffect&&(null!==a.lastEffect&&(a.lastEffect.nextEffect=b.firstEffect),a.lastEffect=b.lastEffect),1<b.flags&&(null!==
|
||||
a.lastEffect?a.lastEffect.nextEffect=b:a.firstEffect=b,a.lastEffect=b));}else {c=Li(b);if(null!==c){c.flags&=2047;Y=c;return}null!==a&&(a.firstEffect=a.lastEffect=null,a.flags|=2048);}b=b.sibling;if(null!==b){Y=b;return}Y=b=a;}while(null!==b);0===V&&(V=5);}function Uj(a){var b=eg();gg(99,dk.bind(null,a,b));return null}
|
||||
function dk(a,b){do Oj();while(null!==yj);if(0!==(X&48))throw Error(y(327));var c=a.finishedWork;if(null===c)return null;a.finishedWork=null;a.finishedLanes=0;if(c===a.current)throw Error(y(177));a.callbackNode=null;var d=c.lanes|c.childLanes,e=d,f=a.pendingLanes&~e;a.pendingLanes=e;a.suspendedLanes=0;a.pingedLanes=0;a.expiredLanes&=e;a.mutableReadLanes&=e;a.entangledLanes&=e;e=a.entanglements;for(var g=a.eventTimes,h=a.expirationTimes;0<f;){var k=31-Vc(f),l=1<<k;e[k]=0;g[k]=-1;h[k]=-1;f&=~l;}null!==
|
||||
Cj&&0===(d&24)&&Cj.has(a)&&Cj.delete(a);a===U&&(Y=U=null,W=0);1<c.flags?null!==c.lastEffect?(c.lastEffect.nextEffect=c,d=c.firstEffect):d=c:d=c.firstEffect;if(null!==d){e=X;X|=32;pj.current=null;kf=fd;g=Ne();if(Oe(g)){if("selectionStart"in g)h={start:g.selectionStart,end:g.selectionEnd};else a:if(h=(h=g.ownerDocument)&&h.defaultView||window,(l=h.getSelection&&h.getSelection())&&0!==l.rangeCount){h=l.anchorNode;f=l.anchorOffset;k=l.focusNode;l=l.focusOffset;try{h.nodeType,k.nodeType;}catch(va){h=null;
|
||||
break a}var n=0,A=-1,p=-1,C=0,x=0,w=g,z=null;b:for(;;){for(var u;;){w!==h||0!==f&&3!==w.nodeType||(A=n+f);w!==k||0!==l&&3!==w.nodeType||(p=n+l);3===w.nodeType&&(n+=w.nodeValue.length);if(null===(u=w.firstChild))break;z=w;w=u;}for(;;){if(w===g)break b;z===h&&++C===f&&(A=n);z===k&&++x===l&&(p=n);if(null!==(u=w.nextSibling))break;w=z;z=w.parentNode;}w=u;}h=-1===A||-1===p?null:{start:A,end:p};}else h=null;h=h||{start:0,end:0};}else h=null;lf={focusedElem:g,selectionRange:h};fd=!1;Ij=null;Jj=!1;Z=d;do try{ek();}catch(va){if(null===
|
||||
Z)throw Error(y(330));Wi(Z,va);Z=Z.nextEffect;}while(null!==Z);Ij=null;Z=d;do try{for(g=a;null!==Z;){var t=Z.flags;t&16&&pb(Z.stateNode,"");if(t&128){var q=Z.alternate;if(null!==q){var v=q.ref;null!==v&&("function"===typeof v?v(null):v.current=null);}}switch(t&1038){case 2:fj(Z);Z.flags&=-3;break;case 6:fj(Z);Z.flags&=-3;ij(Z.alternate,Z);break;case 1024:Z.flags&=-1025;break;case 1028:Z.flags&=-1025;ij(Z.alternate,Z);break;case 4:ij(Z.alternate,Z);break;case 8:h=Z;cj(g,h);var J=h.alternate;dj(h);null!==
|
||||
J&&dj(J);}Z=Z.nextEffect;}}catch(va){if(null===Z)throw Error(y(330));Wi(Z,va);Z=Z.nextEffect;}while(null!==Z);v=lf;q=Ne();t=v.focusedElem;g=v.selectionRange;if(q!==t&&t&&t.ownerDocument&&Me(t.ownerDocument.documentElement,t)){null!==g&&Oe(t)&&(q=g.start,v=g.end,void 0===v&&(v=q),"selectionStart"in t?(t.selectionStart=q,t.selectionEnd=Math.min(v,t.value.length)):(v=(q=t.ownerDocument||document)&&q.defaultView||window,v.getSelection&&(v=v.getSelection(),h=t.textContent.length,J=Math.min(g.start,h),g=void 0===
|
||||
g.end?J:Math.min(g.end,h),!v.extend&&J>g&&(h=g,g=J,J=h),h=Le(t,J),f=Le(t,g),h&&f&&(1!==v.rangeCount||v.anchorNode!==h.node||v.anchorOffset!==h.offset||v.focusNode!==f.node||v.focusOffset!==f.offset)&&(q=q.createRange(),q.setStart(h.node,h.offset),v.removeAllRanges(),J>g?(v.addRange(q),v.extend(f.node,f.offset)):(q.setEnd(f.node,f.offset),v.addRange(q))))));q=[];for(v=t;v=v.parentNode;)1===v.nodeType&&q.push({element:v,left:v.scrollLeft,top:v.scrollTop});"function"===typeof t.focus&&t.focus();for(t=
|
||||
0;t<q.length;t++)v=q[t],v.element.scrollLeft=v.left,v.element.scrollTop=v.top;}fd=!!kf;lf=kf=null;a.current=c;Z=d;do try{for(t=a;null!==Z;){var K=Z.flags;K&36&&Yi(t,Z.alternate,Z);if(K&128){q=void 0;var Q=Z.ref;if(null!==Q){var L=Z.stateNode;switch(Z.tag){case 5:q=L;break;default:q=L;}"function"===typeof Q?Q(q):Q.current=q;}}Z=Z.nextEffect;}}catch(va){if(null===Z)throw Error(y(330));Wi(Z,va);Z=Z.nextEffect;}while(null!==Z);Z=null;$f();X=e;}else a.current=c;if(xj)xj=!1,yj=a,zj=b;else for(Z=d;null!==Z;)b=
|
||||
Z.nextEffect,Z.nextEffect=null,Z.flags&8&&(K=Z,K.sibling=null,K.stateNode=null),Z=b;d=a.pendingLanes;0===d&&(Ti=null);1===d?a===Ej?Dj++:(Dj=0,Ej=a):Dj=0;c=c.stateNode;if(Mf&&"function"===typeof Mf.onCommitFiberRoot)try{Mf.onCommitFiberRoot(Lf,c,void 0,64===(c.current.flags&64));}catch(va){}Mj(a,O());if(Qi)throw Qi=!1,a=Ri,Ri=null,a;if(0!==(X&8))return null;ig();return null}
|
||||
function ek(){for(;null!==Z;){var a=Z.alternate;Jj||null===Ij||(0!==(Z.flags&8)?dc(Z,Ij)&&(Jj=!0):13===Z.tag&&mj(a,Z)&&dc(Z,Ij)&&(Jj=!0));var b=Z.flags;0!==(b&256)&&Xi(a,Z);0===(b&512)||xj||(xj=!0,hg(97,function(){Oj();return null}));Z=Z.nextEffect;}}function Oj(){if(90!==zj){var a=97<zj?97:zj;zj=90;return gg(a,fk)}return !1}function $i(a,b){Aj.push(b,a);xj||(xj=!0,hg(97,function(){Oj();return null}));}function Zi(a,b){Bj.push(b,a);xj||(xj=!0,hg(97,function(){Oj();return null}));}
|
||||
function fk(){if(null===yj)return !1;var a=yj;yj=null;if(0!==(X&48))throw Error(y(331));var b=X;X|=32;var c=Bj;Bj=[];for(var d=0;d<c.length;d+=2){var e=c[d],f=c[d+1],g=e.destroy;e.destroy=void 0;if("function"===typeof g)try{g();}catch(k){if(null===f)throw Error(y(330));Wi(f,k);}}c=Aj;Aj=[];for(d=0;d<c.length;d+=2){e=c[d];f=c[d+1];try{var h=e.create;e.destroy=h();}catch(k){if(null===f)throw Error(y(330));Wi(f,k);}}for(h=a.current.firstEffect;null!==h;)a=h.nextEffect,h.nextEffect=null,h.flags&8&&(h.sibling=
|
||||
null,h.stateNode=null),h=a;X=b;ig();return !0}function gk(a,b,c){b=Mi(c,b);b=Pi(a,b,1);Ag(a,b);b=Hg();a=Kj(a,1);null!==a&&($c(a,1,b),Mj(a,b));}
|
||||
function Wi(a,b){if(3===a.tag)gk(a,a,b);else for(var c=a.return;null!==c;){if(3===c.tag){gk(c,a,b);break}else if(1===c.tag){var d=c.stateNode;if("function"===typeof c.type.getDerivedStateFromError||"function"===typeof d.componentDidCatch&&(null===Ti||!Ti.has(d))){a=Mi(b,a);var e=Si(c,a,1);Ag(c,e);e=Hg();c=Kj(c,1);if(null!==c)$c(c,1,e),Mj(c,e);else if("function"===typeof d.componentDidCatch&&(null===Ti||!Ti.has(d)))try{d.componentDidCatch(b,a);}catch(f){}break}}c=c.return;}}
|
||||
function Yj(a,b,c){var d=a.pingCache;null!==d&&d.delete(b);b=Hg();a.pingedLanes|=a.suspendedLanes&c;U===a&&(W&c)===c&&(4===V||3===V&&(W&62914560)===W&&500>O()-jj?Qj(a,0):uj|=c);Mj(a,b);}function lj(a,b){var c=a.stateNode;null!==c&&c.delete(b);b=0;0===b&&(b=a.mode,0===(b&2)?b=1:0===(b&4)?b=99===eg()?1:2:(0===Gj&&(Gj=tj),b=Yc(62914560&~Gj),0===b&&(b=4194304)));c=Hg();a=Kj(a,b);null!==a&&($c(a,b,c),Mj(a,c));}var ck;
|
||||
ck=function(a,b,c){var d=b.lanes;if(null!==a)if(a.memoizedProps!==b.pendingProps||N.current)ug=!0;else if(0!==(c&d))ug=0!==(a.flags&16384)?!0:!1;else {ug=!1;switch(b.tag){case 3:ri(b);sh();break;case 5:gh(b);break;case 1:Ff(b.type)&&Jf(b);break;case 4:eh(b,b.stateNode.containerInfo);break;case 10:d=b.memoizedProps.value;var e=b.type._context;I(mg,e._currentValue);e._currentValue=d;break;case 13:if(null!==b.memoizedState){if(0!==(c&b.child.childLanes))return ti(a,b,c);I(P,P.current&1);b=hi(a,b,c);return null!==
|
||||
b?b.sibling:null}I(P,P.current&1);break;case 19:d=0!==(c&b.childLanes);if(0!==(a.flags&64)){if(d)return Ai(a,b,c);b.flags|=64;}e=b.memoizedState;null!==e&&(e.rendering=null,e.tail=null,e.lastEffect=null);I(P,P.current);if(d)break;else return null;case 23:case 24:return b.lanes=0,mi(a,b,c)}return hi(a,b,c)}else ug=!1;b.lanes=0;switch(b.tag){case 2:d=b.type;null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2);a=b.pendingProps;e=Ef(b,M.current);tg(b,c);e=Ch(null,b,d,a,e,c);b.flags|=1;if("object"===
|
||||
typeof e&&null!==e&&"function"===typeof e.render&&void 0===e.$$typeof){b.tag=1;b.memoizedState=null;b.updateQueue=null;if(Ff(d)){var f=!0;Jf(b);}else f=!1;b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null;xg(b);var g=d.getDerivedStateFromProps;"function"===typeof g&&Gg(b,d,g,a);e.updater=Kg;b.stateNode=e;e._reactInternals=b;Og(b,d,a,c);b=qi(null,b,d,!0,f,c);}else b.tag=0,fi(null,b,e,c),b=b.child;return b;case 16:e=b.elementType;a:{null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2);
|
||||
a=b.pendingProps;f=e._init;e=f(e._payload);b.type=e;f=b.tag=hk(e);a=lg(e,a);switch(f){case 0:b=li(null,b,e,a,c);break a;case 1:b=pi(null,b,e,a,c);break a;case 11:b=gi(null,b,e,a,c);break a;case 14:b=ii(null,b,e,lg(e.type,a),d,c);break a}throw Error(y(306,e,""));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:lg(d,e),li(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:lg(d,e),pi(a,b,d,e,c);case 3:ri(b);d=b.updateQueue;if(null===a||null===d)throw Error(y(282));
|
||||
d=b.pendingProps;e=b.memoizedState;e=null!==e?e.element:null;yg(a,b);Cg(b,d,null,c);d=b.memoizedState.element;if(d===e)sh(),b=hi(a,b,c);else {e=b.stateNode;if(f=e.hydrate)kh=rf(b.stateNode.containerInfo.firstChild),jh=b,f=lh=!0;if(f){a=e.mutableSourceEagerHydrationData;if(null!=a)for(e=0;e<a.length;e+=2)f=a[e],f._workInProgressVersionPrimary=a[e+1],th.push(f);c=Zg(b,null,d,c);for(b.child=c;c;)c.flags=c.flags&-3|1024,c=c.sibling;}else fi(a,b,d,c),sh();b=b.child;}return b;case 5:return gh(b),null===a&&
|
||||
ph(b),d=b.type,e=b.pendingProps,f=null!==a?a.memoizedProps:null,g=e.children,nf(d,e)?g=null:null!==f&&nf(d,f)&&(b.flags|=16),oi(a,b),fi(a,b,g,c),b.child;case 6:return null===a&&ph(b),null;case 13:return ti(a,b,c);case 4:return eh(b,b.stateNode.containerInfo),d=b.pendingProps,null===a?b.child=Yg(b,null,d,c):fi(a,b,d,c),b.child;case 11:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:lg(d,e),gi(a,b,d,e,c);case 7:return fi(a,b,b.pendingProps,c),b.child;case 8:return fi(a,b,b.pendingProps.children,
|
||||
c),b.child;case 12:return fi(a,b,b.pendingProps.children,c),b.child;case 10:a:{d=b.type._context;e=b.pendingProps;g=b.memoizedProps;f=e.value;var h=b.type._context;I(mg,h._currentValue);h._currentValue=f;if(null!==g)if(h=g.value,f=He(h,f)?0:("function"===typeof d._calculateChangedBits?d._calculateChangedBits(h,f):1073741823)|0,0===f){if(g.children===e.children&&!N.current){b=hi(a,b,c);break a}}else for(h=b.child,null!==h&&(h.return=b);null!==h;){var k=h.dependencies;if(null!==k){g=h.child;for(var l=
|
||||
k.firstContext;null!==l;){if(l.context===d&&0!==(l.observedBits&f)){1===h.tag&&(l=zg(-1,c&-c),l.tag=2,Ag(h,l));h.lanes|=c;l=h.alternate;null!==l&&(l.lanes|=c);sg(h.return,c);k.lanes|=c;break}l=l.next;}}else g=10===h.tag?h.type===b.type?null:h.child:h.child;if(null!==g)g.return=h;else for(g=h;null!==g;){if(g===b){g=null;break}h=g.sibling;if(null!==h){h.return=g.return;g=h;break}g=g.return;}h=g;}fi(a,b,e.children,c);b=b.child;}return b;case 9:return e=b.type,f=b.pendingProps,d=f.children,tg(b,c),e=vg(e,
|
||||
f.unstable_observedBits),d=d(e),b.flags|=1,fi(a,b,d,c),b.child;case 14:return e=b.type,f=lg(e,b.pendingProps),f=lg(e.type,f),ii(a,b,e,f,d,c);case 15:return ki(a,b,b.type,b.pendingProps,d,c);case 17:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:lg(d,e),null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2),b.tag=1,Ff(d)?(a=!0,Jf(b)):a=!1,tg(b,c),Mg(b,d,e),Og(b,d,e,c),qi(null,b,d,!0,a,c);case 19:return Ai(a,b,c);case 23:return mi(a,b,c);case 24:return mi(a,b,c)}throw Error(y(156,b.tag));
|
||||
};function ik(a,b,c,d){this.tag=a;this.key=c;this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null;this.index=0;this.ref=null;this.pendingProps=b;this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null;this.mode=d;this.flags=0;this.lastEffect=this.firstEffect=this.nextEffect=null;this.childLanes=this.lanes=0;this.alternate=null;}function nh(a,b,c,d){return new ik(a,b,c,d)}function ji(a){a=a.prototype;return !(!a||!a.isReactComponent)}
|
||||
function hk(a){if("function"===typeof a)return ji(a)?1:0;if(void 0!==a&&null!==a){a=a.$$typeof;if(a===Aa)return 11;if(a===Da)return 14}return 2}
|
||||
function Tg(a,b){var c=a.alternate;null===c?(c=nh(a.tag,b,a.key,a.mode),c.elementType=a.elementType,c.type=a.type,c.stateNode=a.stateNode,c.alternate=a,a.alternate=c):(c.pendingProps=b,c.type=a.type,c.flags=0,c.nextEffect=null,c.firstEffect=null,c.lastEffect=null);c.childLanes=a.childLanes;c.lanes=a.lanes;c.child=a.child;c.memoizedProps=a.memoizedProps;c.memoizedState=a.memoizedState;c.updateQueue=a.updateQueue;b=a.dependencies;c.dependencies=null===b?null:{lanes:b.lanes,firstContext:b.firstContext};
|
||||
c.sibling=a.sibling;c.index=a.index;c.ref=a.ref;return c}
|
||||
function Vg(a,b,c,d,e,f){var g=2;d=a;if("function"===typeof a)ji(a)&&(g=1);else if("string"===typeof a)g=5;else a:switch(a){case ua:return Xg(c.children,e,f,b);case Ha:g=8;e|=16;break;case wa:g=8;e|=1;break;case xa:return a=nh(12,c,b,e|8),a.elementType=xa,a.type=xa,a.lanes=f,a;case Ba:return a=nh(13,c,b,e),a.type=Ba,a.elementType=Ba,a.lanes=f,a;case Ca:return a=nh(19,c,b,e),a.elementType=Ca,a.lanes=f,a;case Ia:return vi(c,e,f,b);case Ja:return a=nh(24,c,b,e),a.elementType=Ja,a.lanes=f,a;default:if("object"===
|
||||
typeof a&&null!==a)switch(a.$$typeof){case ya:g=10;break a;case za:g=9;break a;case Aa:g=11;break a;case Da:g=14;break a;case Ea:g=16;d=null;break a;case Fa:g=22;break a}throw Error(y(130,null==a?a:typeof a,""));}b=nh(g,c,b,e);b.elementType=a;b.type=d;b.lanes=f;return b}function Xg(a,b,c,d){a=nh(7,a,d,b);a.lanes=c;return a}function vi(a,b,c,d){a=nh(23,a,d,b);a.elementType=Ia;a.lanes=c;return a}function Ug(a,b,c){a=nh(6,a,null,b);a.lanes=c;return a}
|
||||
function Wg(a,b,c){b=nh(4,null!==a.children?a.children:[],a.key,b);b.lanes=c;b.stateNode={containerInfo:a.containerInfo,pendingChildren:null,implementation:a.implementation};return b}
|
||||
function jk(a,b,c){this.tag=b;this.containerInfo=a;this.finishedWork=this.pingCache=this.current=this.pendingChildren=null;this.timeoutHandle=-1;this.pendingContext=this.context=null;this.hydrate=c;this.callbackNode=null;this.callbackPriority=0;this.eventTimes=Zc(0);this.expirationTimes=Zc(-1);this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0;this.entanglements=Zc(0);this.mutableSourceEagerHydrationData=null;}
|
||||
function kk(a,b,c){var d=3<arguments.length&&void 0!==arguments[3]?arguments[3]:null;return {$$typeof:ta,key:null==d?null:""+d,children:a,containerInfo:b,implementation:c}}
|
||||
function lk(a,b,c,d){var e=b.current,f=Hg(),g=Ig(e);a:if(c){c=c._reactInternals;b:{if(Zb(c)!==c||1!==c.tag)throw Error(y(170));var h=c;do{switch(h.tag){case 3:h=h.stateNode.context;break b;case 1:if(Ff(h.type)){h=h.stateNode.__reactInternalMemoizedMergedChildContext;break b}}h=h.return;}while(null!==h);throw Error(y(171));}if(1===c.tag){var k=c.type;if(Ff(k)){c=If(c,k,h);break a}}c=h;}else c=Cf;null===b.context?b.context=c:b.pendingContext=c;b=zg(f,g);b.payload={element:a};d=void 0===d?null:d;null!==
|
||||
d&&(b.callback=d);Ag(e,b);Jg(e,g,f);return g}function mk(a){a=a.current;if(!a.child)return null;switch(a.child.tag){case 5:return a.child.stateNode;default:return a.child.stateNode}}function nk(a,b){a=a.memoizedState;if(null!==a&&null!==a.dehydrated){var c=a.retryLane;a.retryLane=0!==c&&c<b?c:b;}}function ok(a,b){nk(a,b);(a=a.alternate)&&nk(a,b);}function pk(){return null}
|
||||
function qk(a,b,c){var d=null!=c&&null!=c.hydrationOptions&&c.hydrationOptions.mutableSources||null;c=new jk(a,b,null!=c&&!0===c.hydrate);b=nh(3,null,null,2===b?7:1===b?3:0);c.current=b;b.stateNode=c;xg(b);a[ff]=c.current;cf(8===a.nodeType?a.parentNode:a);if(d)for(a=0;a<d.length;a++){b=d[a];var e=b._getVersion;e=e(b._source);null==c.mutableSourceEagerHydrationData?c.mutableSourceEagerHydrationData=[b,e]:c.mutableSourceEagerHydrationData.push(b,e);}this._internalRoot=c;}
|
||||
qk.prototype.render=function(a){lk(a,this._internalRoot,null,null);};qk.prototype.unmount=function(){var a=this._internalRoot,b=a.containerInfo;lk(null,a,null,function(){b[ff]=null;});};function rk(a){return !(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType&&(8!==a.nodeType||" react-mount-point-unstable "!==a.nodeValue))}
|
||||
function sk(a,b){b||(b=a?9===a.nodeType?a.documentElement:a.firstChild:null,b=!(!b||1!==b.nodeType||!b.hasAttribute("data-reactroot")));if(!b)for(var c;c=a.lastChild;)a.removeChild(c);return new qk(a,0,b?{hydrate:!0}:void 0)}
|
||||
function tk(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f._internalRoot;if("function"===typeof e){var h=e;e=function(){var a=mk(g);h.call(a);};}lk(b,g,a,e);}else {f=c._reactRootContainer=sk(c,d);g=f._internalRoot;if("function"===typeof e){var k=e;e=function(){var a=mk(g);k.call(a);};}Xj(function(){lk(b,g,a,e);});}return mk(g)}ec=function(a){if(13===a.tag){var b=Hg();Jg(a,4,b);ok(a,4);}};fc=function(a){if(13===a.tag){var b=Hg();Jg(a,67108864,b);ok(a,67108864);}};
|
||||
gc=function(a){if(13===a.tag){var b=Hg(),c=Ig(a);Jg(a,c,b);ok(a,c);}};hc=function(a,b){return b()};
|
||||
yb=function(a,b,c){switch(b){case "input":ab(a,c);b=c.name;if("radio"===c.type&&null!=b){for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll("input[name="+JSON.stringify(""+b)+'][type="radio"]');for(b=0;b<c.length;b++){var d=c[b];if(d!==a&&d.form===a.form){var e=Db(d);if(!e)throw Error(y(90));Wa(d);ab(d,e);}}}break;case "textarea":ib(a,c);break;case "select":b=c.value,null!=b&&fb(a,!!c.multiple,b,!1);}};Gb=Wj;
|
||||
Hb=function(a,b,c,d,e){var f=X;X|=4;try{return gg(98,a.bind(null,b,c,d,e))}finally{X=f,0===X&&(wj(),ig());}};Ib=function(){0===(X&49)&&(Vj(),Oj());};Jb=function(a,b){var c=X;X|=2;try{return a(b)}finally{X=c,0===X&&(wj(),ig());}};function uk(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!rk(b))throw Error(y(200));return kk(a,b,null,c)}var vk={Events:[Cb,ue,Db,Eb,Fb,Oj,{current:!1}]},wk={findFiberByHostInstance:wc,bundleType:0,version:"17.0.2",rendererPackageName:"react-dom"};
|
||||
var xk={bundleType:wk.bundleType,version:wk.version,rendererPackageName:wk.rendererPackageName,rendererConfig:wk.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,overridePropsDeletePath:null,overridePropsRenamePath:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:ra.ReactCurrentDispatcher,findHostInstanceByFiber:function(a){a=cc(a);return null===a?null:a.stateNode},findFiberByHostInstance:wk.findFiberByHostInstance||
|
||||
pk,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null};if("undefined"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__){var yk=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!yk.isDisabled&&yk.supportsFiber)try{Lf=yk.inject(xk),Mf=yk;}catch(a){}}var __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=vk;var createPortal=uk;
|
||||
var findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return a;var b=a._reactInternals;if(void 0===b){if("function"===typeof a.render)throw Error(y(188));throw Error(y(268,Object.keys(a)));}a=cc(b);a=null===a?null:a.stateNode;return a};var flushSync=function(a,b){var c=X;if(0!==(c&48))return a(b);X|=1;try{if(a)return gg(99,a.bind(null,b))}finally{X=c,ig();}};var hydrate=function(a,b,c){if(!rk(b))throw Error(y(200));return tk(null,a,b,!0,c)};
|
||||
var render=function(a,b,c){if(!rk(b))throw Error(y(200));return tk(null,a,b,!1,c)};var unmountComponentAtNode=function(a){if(!rk(a))throw Error(y(40));return a._reactRootContainer?(Xj(function(){tk(null,null,a,!1,function(){a._reactRootContainer=null;a[ff]=null;});}),!0):!1};var unstable_batchedUpdates=Wj;var unstable_createPortal=function(a,b){return uk(a,b,2<arguments.length&&void 0!==arguments[2]?arguments[2]:null)};
|
||||
var unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!rk(c))throw Error(y(200));if(null==a||void 0===a._reactInternals)throw Error(y(38));return tk(a,b,c,!1,d)};var version="17.0.2";
|
||||
|
||||
var reactDom_production_min = {
|
||||
__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
|
||||
createPortal: createPortal,
|
||||
findDOMNode: findDOMNode,
|
||||
flushSync: flushSync,
|
||||
hydrate: hydrate,
|
||||
render: render,
|
||||
unmountComponentAtNode: unmountComponentAtNode,
|
||||
unstable_batchedUpdates: unstable_batchedUpdates,
|
||||
unstable_createPortal: unstable_createPortal,
|
||||
unstable_renderSubtreeIntoContainer: unstable_renderSubtreeIntoContainer,
|
||||
version: version
|
||||
};
|
||||
|
||||
var reactDom = createCommonjsModule(function (module) {
|
||||
|
||||
function checkDCE() {
|
||||
/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
|
||||
if (
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined' ||
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== 'function'
|
||||
) {
|
||||
return;
|
||||
}
|
||||
try {
|
||||
// Verify that the code above has been dead code eliminated (DCE'd).
|
||||
__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
|
||||
} catch (err) {
|
||||
// DevTools shouldn't crash React, no matter what.
|
||||
// We should still report in case we break this code.
|
||||
console.error(err);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
// DCE check should happen before ReactDOM bundle executes so that
|
||||
// DevTools can report bad minification during injection.
|
||||
checkDCE();
|
||||
module.exports = reactDom_production_min;
|
||||
}
|
||||
});
|
||||
|
||||
export default reactDom;
|
||||
14
docs/_snowpack/pkg/react.js
vendored
14
docs/_snowpack/pkg/react.js
vendored
@ -1,14 +0,0 @@
|
||||
import { r as react } from './common/index-67cfdec9.js';
|
||||
export { r as default } from './common/index-67cfdec9.js';
|
||||
import './common/_commonjsHelpers-8c19dec8.js';
|
||||
import './common/index-d01087d6.js';
|
||||
|
||||
|
||||
|
||||
var useCallback = react.useCallback;
|
||||
var useEffect = react.useEffect;
|
||||
var useLayoutEffect = react.useLayoutEffect;
|
||||
var useMemo = react.useMemo;
|
||||
var useRef = react.useRef;
|
||||
var useState = react.useState;
|
||||
export { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState };
|
||||
@ -1,106 +0,0 @@
|
||||
import { _ as __pika_web_default_export_for_treeshaking__, d as dist } from './common/index-1e63141f.js';
|
||||
export { d as __moduleExports, _ as default } from './common/index-1e63141f.js';
|
||||
import './common/_commonjsHelpers-8c19dec8.js';
|
||||
|
||||
|
||||
|
||||
var ArrayAssignmentTarget = dist.ArrayAssignmentTarget;
|
||||
var ArrayBinding = dist.ArrayBinding;
|
||||
var ArrayExpression = dist.ArrayExpression;
|
||||
var ArrowExpression = dist.ArrowExpression;
|
||||
var AssignmentExpression = dist.AssignmentExpression;
|
||||
var AssignmentTargetIdentifier = dist.AssignmentTargetIdentifier;
|
||||
var AssignmentTargetPropertyIdentifier = dist.AssignmentTargetPropertyIdentifier;
|
||||
var AssignmentTargetPropertyProperty = dist.AssignmentTargetPropertyProperty;
|
||||
var AssignmentTargetWithDefault = dist.AssignmentTargetWithDefault;
|
||||
var AwaitExpression = dist.AwaitExpression;
|
||||
var BinaryExpression = dist.BinaryExpression;
|
||||
var BindingIdentifier = dist.BindingIdentifier;
|
||||
var BindingPropertyIdentifier = dist.BindingPropertyIdentifier;
|
||||
var BindingPropertyProperty = dist.BindingPropertyProperty;
|
||||
var BindingWithDefault = dist.BindingWithDefault;
|
||||
var Block = dist.Block;
|
||||
var BlockStatement = dist.BlockStatement;
|
||||
var BreakStatement = dist.BreakStatement;
|
||||
var CallExpression = dist.CallExpression;
|
||||
var CatchClause = dist.CatchClause;
|
||||
var ClassDeclaration = dist.ClassDeclaration;
|
||||
var ClassElement = dist.ClassElement;
|
||||
var ClassExpression = dist.ClassExpression;
|
||||
var CompoundAssignmentExpression = dist.CompoundAssignmentExpression;
|
||||
var ComputedMemberAssignmentTarget = dist.ComputedMemberAssignmentTarget;
|
||||
var ComputedMemberExpression = dist.ComputedMemberExpression;
|
||||
var ComputedPropertyName = dist.ComputedPropertyName;
|
||||
var ConditionalExpression = dist.ConditionalExpression;
|
||||
var ContinueStatement = dist.ContinueStatement;
|
||||
var DataProperty = dist.DataProperty;
|
||||
var DebuggerStatement = dist.DebuggerStatement;
|
||||
var Directive = dist.Directive;
|
||||
var DoWhileStatement = dist.DoWhileStatement;
|
||||
var EmptyStatement = dist.EmptyStatement;
|
||||
var Export = dist.Export;
|
||||
var ExportAllFrom = dist.ExportAllFrom;
|
||||
var ExportDefault = dist.ExportDefault;
|
||||
var ExportFrom = dist.ExportFrom;
|
||||
var ExportFromSpecifier = dist.ExportFromSpecifier;
|
||||
var ExportLocalSpecifier = dist.ExportLocalSpecifier;
|
||||
var ExportLocals = dist.ExportLocals;
|
||||
var ExpressionStatement = dist.ExpressionStatement;
|
||||
var ForAwaitStatement = dist.ForAwaitStatement;
|
||||
var ForInStatement = dist.ForInStatement;
|
||||
var ForOfStatement = dist.ForOfStatement;
|
||||
var ForStatement = dist.ForStatement;
|
||||
var FormalParameters = dist.FormalParameters;
|
||||
var FunctionBody = dist.FunctionBody;
|
||||
var FunctionDeclaration = dist.FunctionDeclaration;
|
||||
var FunctionExpression = dist.FunctionExpression;
|
||||
var Getter = dist.Getter;
|
||||
var IdentifierExpression = dist.IdentifierExpression;
|
||||
var IfStatement = dist.IfStatement;
|
||||
var Import = dist.Import;
|
||||
var ImportNamespace = dist.ImportNamespace;
|
||||
var ImportSpecifier = dist.ImportSpecifier;
|
||||
var LabeledStatement = dist.LabeledStatement;
|
||||
var LiteralBooleanExpression = dist.LiteralBooleanExpression;
|
||||
var LiteralInfinityExpression = dist.LiteralInfinityExpression;
|
||||
var LiteralNullExpression = dist.LiteralNullExpression;
|
||||
var LiteralNumericExpression = dist.LiteralNumericExpression;
|
||||
var LiteralRegExpExpression = dist.LiteralRegExpExpression;
|
||||
var LiteralStringExpression = dist.LiteralStringExpression;
|
||||
var Method = dist.Method;
|
||||
var Module = dist.Module;
|
||||
var NewExpression = dist.NewExpression;
|
||||
var NewTargetExpression = dist.NewTargetExpression;
|
||||
var ObjectAssignmentTarget = dist.ObjectAssignmentTarget;
|
||||
var ObjectBinding = dist.ObjectBinding;
|
||||
var ObjectExpression = dist.ObjectExpression;
|
||||
var ReturnStatement = dist.ReturnStatement;
|
||||
var Script = dist.Script;
|
||||
var Setter = dist.Setter;
|
||||
var ShorthandProperty = dist.ShorthandProperty;
|
||||
var SpreadElement = dist.SpreadElement;
|
||||
var SpreadProperty = dist.SpreadProperty;
|
||||
var StaticMemberAssignmentTarget = dist.StaticMemberAssignmentTarget;
|
||||
var StaticMemberExpression = dist.StaticMemberExpression;
|
||||
var StaticPropertyName = dist.StaticPropertyName;
|
||||
var Super = dist.Super;
|
||||
var SwitchCase = dist.SwitchCase;
|
||||
var SwitchDefault = dist.SwitchDefault;
|
||||
var SwitchStatement = dist.SwitchStatement;
|
||||
var SwitchStatementWithDefault = dist.SwitchStatementWithDefault;
|
||||
var TemplateElement = dist.TemplateElement;
|
||||
var TemplateExpression = dist.TemplateExpression;
|
||||
var ThisExpression = dist.ThisExpression;
|
||||
var ThrowStatement = dist.ThrowStatement;
|
||||
var TryCatchStatement = dist.TryCatchStatement;
|
||||
var TryFinallyStatement = dist.TryFinallyStatement;
|
||||
var UnaryExpression = dist.UnaryExpression;
|
||||
var UpdateExpression = dist.UpdateExpression;
|
||||
var VariableDeclaration = dist.VariableDeclaration;
|
||||
var VariableDeclarationStatement = dist.VariableDeclarationStatement;
|
||||
var VariableDeclarator = dist.VariableDeclarator;
|
||||
var WhileStatement = dist.WhileStatement;
|
||||
var WithStatement = dist.WithStatement;
|
||||
var YieldExpression = dist.YieldExpression;
|
||||
var YieldGeneratorExpression = dist.YieldGeneratorExpression;
|
||||
export { ArrayAssignmentTarget, ArrayBinding, ArrayExpression, ArrowExpression, AssignmentExpression, AssignmentTargetIdentifier, AssignmentTargetPropertyIdentifier, AssignmentTargetPropertyProperty, AssignmentTargetWithDefault, AwaitExpression, BinaryExpression, BindingIdentifier, BindingPropertyIdentifier, BindingPropertyProperty, BindingWithDefault, Block, BlockStatement, BreakStatement, CallExpression, CatchClause, ClassDeclaration, ClassElement, ClassExpression, CompoundAssignmentExpression, ComputedMemberAssignmentTarget, ComputedMemberExpression, ComputedPropertyName, ConditionalExpression, ContinueStatement, DataProperty, DebuggerStatement, Directive, DoWhileStatement, EmptyStatement, Export, ExportAllFrom, ExportDefault, ExportFrom, ExportFromSpecifier, ExportLocalSpecifier, ExportLocals, ExpressionStatement, ForAwaitStatement, ForInStatement, ForOfStatement, ForStatement, FormalParameters, FunctionBody, FunctionDeclaration, FunctionExpression, Getter, IdentifierExpression, IfStatement, Import, ImportNamespace, ImportSpecifier, LabeledStatement, LiteralBooleanExpression, LiteralInfinityExpression, LiteralNullExpression, LiteralNumericExpression, LiteralRegExpExpression, LiteralStringExpression, Method, Module, NewExpression, NewTargetExpression, ObjectAssignmentTarget, ObjectBinding, ObjectExpression, ReturnStatement, Script, Setter, ShorthandProperty, SpreadElement, SpreadProperty, StaticMemberAssignmentTarget, StaticMemberExpression, StaticPropertyName, Super, SwitchCase, SwitchDefault, SwitchStatement, SwitchStatementWithDefault, TemplateElement, TemplateExpression, ThisExpression, ThrowStatement, TryCatchStatement, TryFinallyStatement, UnaryExpression, UpdateExpression, VariableDeclaration, VariableDeclarationStatement, VariableDeclarator, WhileStatement, WithStatement, YieldExpression, YieldGeneratorExpression };
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@ -1,876 +0,0 @@
|
||||
import { g as getDefaultExportFromCjs, c as createCommonjsModule } from './common/_commonjsHelpers-8c19dec8.js';
|
||||
|
||||
var dist = createCommonjsModule(function (module, exports) {
|
||||
// Generated by src/generate-spec.js.
|
||||
|
||||
/**
|
||||
* Copyright 2016 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
// Hack to make Babel6 import this as a module.
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
|
||||
exports.default = (function() {
|
||||
var SPEC = {};
|
||||
|
||||
var BOOLEAN = { typeName: "Boolean" };
|
||||
var DOUBLE = { typeName: "Number" };
|
||||
var STRING = { typeName: "String" };
|
||||
function Maybe(arg) { return { typeName: "Maybe", argument: arg }; }
|
||||
function List(arg) { return { typeName: "List", argument: arg }; }
|
||||
function Const(arg) { return { typeName: "Const", argument: arg }; }
|
||||
function Union() { return { typeName: "Union", arguments: [].slice.call(arguments, 0) }; }
|
||||
|
||||
|
||||
var TYPE_INDICATOR = {
|
||||
typeName: "Enum",
|
||||
values: ["ArrayAssignmentTarget", "ArrayBinding", "ArrayExpression", "ArrowExpression", "AssignmentExpression", "AssignmentTargetIdentifier", "AssignmentTargetPropertyIdentifier", "AssignmentTargetPropertyProperty", "AssignmentTargetWithDefault", "AwaitExpression", "BinaryExpression", "BindingIdentifier", "BindingPropertyIdentifier", "BindingPropertyProperty", "BindingWithDefault", "Block", "BlockStatement", "BreakStatement", "CallExpression", "CatchClause", "ClassDeclaration", "ClassElement", "ClassExpression", "CompoundAssignmentExpression", "ComputedMemberAssignmentTarget", "ComputedMemberExpression", "ComputedPropertyName", "ConditionalExpression", "ContinueStatement", "DataProperty", "DebuggerStatement", "Directive", "DoWhileStatement", "EmptyStatement", "Export", "ExportAllFrom", "ExportDefault", "ExportFrom", "ExportFromSpecifier", "ExportLocalSpecifier", "ExportLocals", "ExpressionStatement", "ForAwaitStatement", "ForInStatement", "ForOfStatement", "ForStatement", "FormalParameters", "FunctionBody", "FunctionDeclaration", "FunctionExpression", "Getter", "IdentifierExpression", "IfStatement", "Import", "ImportNamespace", "ImportSpecifier", "LabeledStatement", "LiteralBooleanExpression", "LiteralInfinityExpression", "LiteralNullExpression", "LiteralNumericExpression", "LiteralRegExpExpression", "LiteralStringExpression", "Method", "Module", "NewExpression", "NewTargetExpression", "ObjectAssignmentTarget", "ObjectBinding", "ObjectExpression", "ReturnStatement", "Script", "Setter", "ShorthandProperty", "SpreadElement", "SpreadProperty", "StaticMemberAssignmentTarget", "StaticMemberExpression", "StaticPropertyName", "Super", "SwitchCase", "SwitchDefault", "SwitchStatement", "SwitchStatementWithDefault", "TemplateElement", "TemplateExpression", "ThisExpression", "ThrowStatement", "TryCatchStatement", "TryFinallyStatement", "UnaryExpression", "UpdateExpression", "VariableDeclaration", "VariableDeclarationStatement", "VariableDeclarator", "WhileStatement", "WithStatement", "YieldExpression", "YieldGeneratorExpression"]
|
||||
};
|
||||
|
||||
var BinaryOperator = {
|
||||
typeName: "Enum",
|
||||
values: ["==", "!=", "===", "!==", "<", "<=", ">", ">=", "in", "instanceof", "<<", ">>", ">>>", "+", "-", "*", "/", "%", "**", ",", "||", "&&", "|", "^", "&"]
|
||||
};
|
||||
|
||||
var CompoundAssignmentOperator = {
|
||||
typeName: "Enum",
|
||||
values: ["+=", "-=", "*=", "/=", "%=", "**=", "<<=", ">>=", ">>>=", "|=", "^=", "&="]
|
||||
};
|
||||
|
||||
var UnaryOperator = {
|
||||
typeName: "Enum",
|
||||
values: ["+", "-", "!", "~", "typeof", "void", "delete"]
|
||||
};
|
||||
|
||||
var UpdateOperator = {
|
||||
typeName: "Enum",
|
||||
values: ["++", "--"]
|
||||
};
|
||||
|
||||
var VariableDeclarationKind = {
|
||||
typeName: "Enum",
|
||||
values: ["var", "let", "const"]
|
||||
};
|
||||
|
||||
|
||||
var ArrayAssignmentTarget = SPEC.ArrayAssignmentTarget = {};
|
||||
var ArrayBinding = SPEC.ArrayBinding = {};
|
||||
var ArrayExpression = SPEC.ArrayExpression = {};
|
||||
var ArrowExpression = SPEC.ArrowExpression = {};
|
||||
var AssignmentExpression = SPEC.AssignmentExpression = {};
|
||||
var AssignmentTargetIdentifier = SPEC.AssignmentTargetIdentifier = {};
|
||||
var AssignmentTargetPropertyIdentifier = SPEC.AssignmentTargetPropertyIdentifier = {};
|
||||
var AssignmentTargetPropertyProperty = SPEC.AssignmentTargetPropertyProperty = {};
|
||||
var AssignmentTargetWithDefault = SPEC.AssignmentTargetWithDefault = {};
|
||||
var AwaitExpression = SPEC.AwaitExpression = {};
|
||||
var BinaryExpression = SPEC.BinaryExpression = {};
|
||||
var BindingIdentifier = SPEC.BindingIdentifier = {};
|
||||
var BindingPropertyIdentifier = SPEC.BindingPropertyIdentifier = {};
|
||||
var BindingPropertyProperty = SPEC.BindingPropertyProperty = {};
|
||||
var BindingWithDefault = SPEC.BindingWithDefault = {};
|
||||
var Block = SPEC.Block = {};
|
||||
var BlockStatement = SPEC.BlockStatement = {};
|
||||
var BreakStatement = SPEC.BreakStatement = {};
|
||||
var CallExpression = SPEC.CallExpression = {};
|
||||
var CatchClause = SPEC.CatchClause = {};
|
||||
var ClassDeclaration = SPEC.ClassDeclaration = {};
|
||||
var ClassElement = SPEC.ClassElement = {};
|
||||
var ClassExpression = SPEC.ClassExpression = {};
|
||||
var CompoundAssignmentExpression = SPEC.CompoundAssignmentExpression = {};
|
||||
var ComputedMemberAssignmentTarget = SPEC.ComputedMemberAssignmentTarget = {};
|
||||
var ComputedMemberExpression = SPEC.ComputedMemberExpression = {};
|
||||
var ComputedPropertyName = SPEC.ComputedPropertyName = {};
|
||||
var ConditionalExpression = SPEC.ConditionalExpression = {};
|
||||
var ContinueStatement = SPEC.ContinueStatement = {};
|
||||
var DataProperty = SPEC.DataProperty = {};
|
||||
var DebuggerStatement = SPEC.DebuggerStatement = {};
|
||||
var Directive = SPEC.Directive = {};
|
||||
var DoWhileStatement = SPEC.DoWhileStatement = {};
|
||||
var EmptyStatement = SPEC.EmptyStatement = {};
|
||||
var Export = SPEC.Export = {};
|
||||
var ExportAllFrom = SPEC.ExportAllFrom = {};
|
||||
var ExportDefault = SPEC.ExportDefault = {};
|
||||
var ExportFrom = SPEC.ExportFrom = {};
|
||||
var ExportFromSpecifier = SPEC.ExportFromSpecifier = {};
|
||||
var ExportLocalSpecifier = SPEC.ExportLocalSpecifier = {};
|
||||
var ExportLocals = SPEC.ExportLocals = {};
|
||||
var ExpressionStatement = SPEC.ExpressionStatement = {};
|
||||
var ForAwaitStatement = SPEC.ForAwaitStatement = {};
|
||||
var ForInStatement = SPEC.ForInStatement = {};
|
||||
var ForOfStatement = SPEC.ForOfStatement = {};
|
||||
var ForStatement = SPEC.ForStatement = {};
|
||||
var FormalParameters = SPEC.FormalParameters = {};
|
||||
var FunctionBody = SPEC.FunctionBody = {};
|
||||
var FunctionDeclaration = SPEC.FunctionDeclaration = {};
|
||||
var FunctionExpression = SPEC.FunctionExpression = {};
|
||||
var Getter = SPEC.Getter = {};
|
||||
var IdentifierExpression = SPEC.IdentifierExpression = {};
|
||||
var IfStatement = SPEC.IfStatement = {};
|
||||
var Import = SPEC.Import = {};
|
||||
var ImportNamespace = SPEC.ImportNamespace = {};
|
||||
var ImportSpecifier = SPEC.ImportSpecifier = {};
|
||||
var LabeledStatement = SPEC.LabeledStatement = {};
|
||||
var LiteralBooleanExpression = SPEC.LiteralBooleanExpression = {};
|
||||
var LiteralInfinityExpression = SPEC.LiteralInfinityExpression = {};
|
||||
var LiteralNullExpression = SPEC.LiteralNullExpression = {};
|
||||
var LiteralNumericExpression = SPEC.LiteralNumericExpression = {};
|
||||
var LiteralRegExpExpression = SPEC.LiteralRegExpExpression = {};
|
||||
var LiteralStringExpression = SPEC.LiteralStringExpression = {};
|
||||
var Method = SPEC.Method = {};
|
||||
var Module = SPEC.Module = {};
|
||||
var NewExpression = SPEC.NewExpression = {};
|
||||
var NewTargetExpression = SPEC.NewTargetExpression = {};
|
||||
var ObjectAssignmentTarget = SPEC.ObjectAssignmentTarget = {};
|
||||
var ObjectBinding = SPEC.ObjectBinding = {};
|
||||
var ObjectExpression = SPEC.ObjectExpression = {};
|
||||
var ReturnStatement = SPEC.ReturnStatement = {};
|
||||
var Script = SPEC.Script = {};
|
||||
var Setter = SPEC.Setter = {};
|
||||
var ShorthandProperty = SPEC.ShorthandProperty = {};
|
||||
var SpreadElement = SPEC.SpreadElement = {};
|
||||
var SpreadProperty = SPEC.SpreadProperty = {};
|
||||
var StaticMemberAssignmentTarget = SPEC.StaticMemberAssignmentTarget = {};
|
||||
var StaticMemberExpression = SPEC.StaticMemberExpression = {};
|
||||
var StaticPropertyName = SPEC.StaticPropertyName = {};
|
||||
var Super = SPEC.Super = {};
|
||||
var SwitchCase = SPEC.SwitchCase = {};
|
||||
var SwitchDefault = SPEC.SwitchDefault = {};
|
||||
var SwitchStatement = SPEC.SwitchStatement = {};
|
||||
var SwitchStatementWithDefault = SPEC.SwitchStatementWithDefault = {};
|
||||
var TemplateElement = SPEC.TemplateElement = {};
|
||||
var TemplateExpression = SPEC.TemplateExpression = {};
|
||||
var ThisExpression = SPEC.ThisExpression = {};
|
||||
var ThrowStatement = SPEC.ThrowStatement = {};
|
||||
var TryCatchStatement = SPEC.TryCatchStatement = {};
|
||||
var TryFinallyStatement = SPEC.TryFinallyStatement = {};
|
||||
var UnaryExpression = SPEC.UnaryExpression = {};
|
||||
var UpdateExpression = SPEC.UpdateExpression = {};
|
||||
var VariableDeclaration = SPEC.VariableDeclaration = {};
|
||||
var VariableDeclarationStatement = SPEC.VariableDeclarationStatement = {};
|
||||
var VariableDeclarator = SPEC.VariableDeclarator = {};
|
||||
var WhileStatement = SPEC.WhileStatement = {};
|
||||
var WithStatement = SPEC.WithStatement = {};
|
||||
var YieldExpression = SPEC.YieldExpression = {};
|
||||
var YieldGeneratorExpression = SPEC.YieldGeneratorExpression = {};
|
||||
|
||||
var MemberExpression = Union(ComputedMemberExpression, StaticMemberExpression);
|
||||
var AssignmentTargetProperty = Union(AssignmentTargetPropertyIdentifier, AssignmentTargetPropertyProperty);
|
||||
var Class = Union(ClassDeclaration, ClassExpression);
|
||||
var ExportDeclaration = Union(Export, ExportAllFrom, ExportDefault, ExportFrom, ExportLocals);
|
||||
var PropertyName = Union(ComputedPropertyName, StaticPropertyName);
|
||||
var Function = Union(FunctionDeclaration, FunctionExpression);
|
||||
var ImportDeclaration = Union(Import, ImportNamespace);
|
||||
var IterationStatement = Union(DoWhileStatement, ForAwaitStatement, ForInStatement, ForOfStatement, ForStatement, WhileStatement);
|
||||
var MemberAssignmentTarget = Union(ComputedMemberAssignmentTarget, StaticMemberAssignmentTarget);
|
||||
var BindingProperty = Union(BindingPropertyIdentifier, BindingPropertyProperty);
|
||||
var MethodDefinition = Union(Getter, Method, Setter);
|
||||
var Program = Union(Module, Script);
|
||||
var VariableReference = Union(AssignmentTargetIdentifier, BindingIdentifier, IdentifierExpression);
|
||||
var NamedObjectProperty = Union(DataProperty, MethodDefinition);
|
||||
var Expression = Union(ArrayExpression, ArrowExpression, AssignmentExpression, AwaitExpression, BinaryExpression, CallExpression, ClassExpression, CompoundAssignmentExpression, ConditionalExpression, FunctionExpression, IdentifierExpression, LiteralBooleanExpression, LiteralInfinityExpression, LiteralNullExpression, LiteralNumericExpression, LiteralRegExpExpression, LiteralStringExpression, MemberExpression, NewExpression, NewTargetExpression, ObjectExpression, TemplateExpression, ThisExpression, UnaryExpression, UpdateExpression, YieldExpression, YieldGeneratorExpression);
|
||||
var Statement = Union(BlockStatement, BreakStatement, ClassDeclaration, ContinueStatement, DebuggerStatement, EmptyStatement, ExpressionStatement, FunctionDeclaration, IfStatement, IterationStatement, LabeledStatement, ReturnStatement, SwitchStatement, SwitchStatementWithDefault, ThrowStatement, TryCatchStatement, TryFinallyStatement, VariableDeclarationStatement, WithStatement);
|
||||
var ObjectProperty = Union(NamedObjectProperty, ShorthandProperty, SpreadProperty);
|
||||
var Node = Union(ArrayAssignmentTarget, ArrayBinding, AssignmentTargetProperty, AssignmentTargetWithDefault, BindingProperty, BindingWithDefault, Block, CatchClause, ClassElement, Directive, ExportDeclaration, ExportFromSpecifier, ExportLocalSpecifier, Expression, FormalParameters, FunctionBody, ImportDeclaration, ImportSpecifier, MemberAssignmentTarget, ObjectAssignmentTarget, ObjectBinding, ObjectProperty, Program, PropertyName, SpreadElement, Statement, Super, SwitchCase, SwitchDefault, TemplateElement, VariableDeclaration, VariableDeclarator, VariableReference);
|
||||
|
||||
ArrayAssignmentTarget.typeName = "ArrayAssignmentTarget";
|
||||
ArrayAssignmentTarget.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ArrayAssignmentTarget" },
|
||||
{ name: "elements", type: List(Maybe(Union(AssignmentTargetWithDefault, Union(Union(ArrayAssignmentTarget, ObjectAssignmentTarget), Union(AssignmentTargetIdentifier, MemberAssignmentTarget))))) },
|
||||
{ name: "rest", type: Maybe(Union(Union(ArrayAssignmentTarget, ObjectAssignmentTarget), Union(AssignmentTargetIdentifier, MemberAssignmentTarget))) }
|
||||
];
|
||||
|
||||
ArrayBinding.typeName = "ArrayBinding";
|
||||
ArrayBinding.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ArrayBinding" },
|
||||
{ name: "elements", type: List(Maybe(Union(BindingWithDefault, Union(BindingIdentifier, Union(ArrayBinding, ObjectBinding))))) },
|
||||
{ name: "rest", type: Maybe(Union(BindingIdentifier, Union(ArrayBinding, ObjectBinding))) }
|
||||
];
|
||||
|
||||
ArrayExpression.typeName = "ArrayExpression";
|
||||
ArrayExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ArrayExpression" },
|
||||
{ name: "elements", type: List(Maybe(Union(Expression, SpreadElement))) }
|
||||
];
|
||||
|
||||
ArrowExpression.typeName = "ArrowExpression";
|
||||
ArrowExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ArrowExpression" },
|
||||
{ name: "isAsync", type: BOOLEAN },
|
||||
{ name: "params", type: FormalParameters },
|
||||
{ name: "body", type: Union(Expression, FunctionBody) }
|
||||
];
|
||||
|
||||
AssignmentExpression.typeName = "AssignmentExpression";
|
||||
AssignmentExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "AssignmentExpression" },
|
||||
{ name: "binding", type: Union(Union(ArrayAssignmentTarget, ObjectAssignmentTarget), Union(AssignmentTargetIdentifier, MemberAssignmentTarget)) },
|
||||
{ name: "expression", type: Expression }
|
||||
];
|
||||
|
||||
AssignmentTargetIdentifier.typeName = "AssignmentTargetIdentifier";
|
||||
AssignmentTargetIdentifier.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "AssignmentTargetIdentifier" },
|
||||
{ name: "name", type: STRING }
|
||||
];
|
||||
|
||||
AssignmentTargetPropertyIdentifier.typeName = "AssignmentTargetPropertyIdentifier";
|
||||
AssignmentTargetPropertyIdentifier.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "AssignmentTargetPropertyIdentifier" },
|
||||
{ name: "binding", type: AssignmentTargetIdentifier },
|
||||
{ name: "init", type: Maybe(Expression) }
|
||||
];
|
||||
|
||||
AssignmentTargetPropertyProperty.typeName = "AssignmentTargetPropertyProperty";
|
||||
AssignmentTargetPropertyProperty.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "AssignmentTargetPropertyProperty" },
|
||||
{ name: "name", type: PropertyName },
|
||||
{ name: "binding", type: Union(AssignmentTargetWithDefault, Union(Union(ArrayAssignmentTarget, ObjectAssignmentTarget), Union(AssignmentTargetIdentifier, MemberAssignmentTarget))) }
|
||||
];
|
||||
|
||||
AssignmentTargetWithDefault.typeName = "AssignmentTargetWithDefault";
|
||||
AssignmentTargetWithDefault.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "AssignmentTargetWithDefault" },
|
||||
{ name: "binding", type: Union(Union(ArrayAssignmentTarget, ObjectAssignmentTarget), Union(AssignmentTargetIdentifier, MemberAssignmentTarget)) },
|
||||
{ name: "init", type: Expression }
|
||||
];
|
||||
|
||||
AwaitExpression.typeName = "AwaitExpression";
|
||||
AwaitExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "AwaitExpression" },
|
||||
{ name: "expression", type: Expression }
|
||||
];
|
||||
|
||||
BinaryExpression.typeName = "BinaryExpression";
|
||||
BinaryExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "BinaryExpression" },
|
||||
{ name: "left", type: Expression },
|
||||
{ name: "operator", type: BinaryOperator },
|
||||
{ name: "right", type: Expression }
|
||||
];
|
||||
|
||||
BindingIdentifier.typeName = "BindingIdentifier";
|
||||
BindingIdentifier.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "BindingIdentifier" },
|
||||
{ name: "name", type: STRING }
|
||||
];
|
||||
|
||||
BindingPropertyIdentifier.typeName = "BindingPropertyIdentifier";
|
||||
BindingPropertyIdentifier.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "BindingPropertyIdentifier" },
|
||||
{ name: "binding", type: BindingIdentifier },
|
||||
{ name: "init", type: Maybe(Expression) }
|
||||
];
|
||||
|
||||
BindingPropertyProperty.typeName = "BindingPropertyProperty";
|
||||
BindingPropertyProperty.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "BindingPropertyProperty" },
|
||||
{ name: "name", type: PropertyName },
|
||||
{ name: "binding", type: Union(BindingWithDefault, Union(BindingIdentifier, Union(ArrayBinding, ObjectBinding))) }
|
||||
];
|
||||
|
||||
BindingWithDefault.typeName = "BindingWithDefault";
|
||||
BindingWithDefault.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "BindingWithDefault" },
|
||||
{ name: "binding", type: Union(BindingIdentifier, Union(ArrayBinding, ObjectBinding)) },
|
||||
{ name: "init", type: Expression }
|
||||
];
|
||||
|
||||
Block.typeName = "Block";
|
||||
Block.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "Block" },
|
||||
{ name: "statements", type: List(Statement) }
|
||||
];
|
||||
|
||||
BlockStatement.typeName = "BlockStatement";
|
||||
BlockStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "BlockStatement" },
|
||||
{ name: "block", type: Block }
|
||||
];
|
||||
|
||||
BreakStatement.typeName = "BreakStatement";
|
||||
BreakStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "BreakStatement" },
|
||||
{ name: "label", type: Maybe(STRING) }
|
||||
];
|
||||
|
||||
CallExpression.typeName = "CallExpression";
|
||||
CallExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "CallExpression" },
|
||||
{ name: "callee", type: Union(Expression, Super) },
|
||||
{ name: "arguments", type: List(Union(Expression, SpreadElement)) }
|
||||
];
|
||||
|
||||
CatchClause.typeName = "CatchClause";
|
||||
CatchClause.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "CatchClause" },
|
||||
{ name: "binding", type: Union(BindingIdentifier, Union(ArrayBinding, ObjectBinding)) },
|
||||
{ name: "body", type: Block }
|
||||
];
|
||||
|
||||
ClassDeclaration.typeName = "ClassDeclaration";
|
||||
ClassDeclaration.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ClassDeclaration" },
|
||||
{ name: "name", type: BindingIdentifier },
|
||||
{ name: "super", type: Maybe(Expression) },
|
||||
{ name: "elements", type: List(ClassElement) }
|
||||
];
|
||||
|
||||
ClassElement.typeName = "ClassElement";
|
||||
ClassElement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ClassElement" },
|
||||
{ name: "isStatic", type: BOOLEAN },
|
||||
{ name: "method", type: MethodDefinition }
|
||||
];
|
||||
|
||||
ClassExpression.typeName = "ClassExpression";
|
||||
ClassExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ClassExpression" },
|
||||
{ name: "name", type: Maybe(BindingIdentifier) },
|
||||
{ name: "super", type: Maybe(Expression) },
|
||||
{ name: "elements", type: List(ClassElement) }
|
||||
];
|
||||
|
||||
CompoundAssignmentExpression.typeName = "CompoundAssignmentExpression";
|
||||
CompoundAssignmentExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "CompoundAssignmentExpression" },
|
||||
{ name: "binding", type: Union(AssignmentTargetIdentifier, MemberAssignmentTarget) },
|
||||
{ name: "operator", type: CompoundAssignmentOperator },
|
||||
{ name: "expression", type: Expression }
|
||||
];
|
||||
|
||||
ComputedMemberAssignmentTarget.typeName = "ComputedMemberAssignmentTarget";
|
||||
ComputedMemberAssignmentTarget.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ComputedMemberAssignmentTarget" },
|
||||
{ name: "object", type: Union(Expression, Super) },
|
||||
{ name: "expression", type: Expression }
|
||||
];
|
||||
|
||||
ComputedMemberExpression.typeName = "ComputedMemberExpression";
|
||||
ComputedMemberExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ComputedMemberExpression" },
|
||||
{ name: "object", type: Union(Expression, Super) },
|
||||
{ name: "expression", type: Expression }
|
||||
];
|
||||
|
||||
ComputedPropertyName.typeName = "ComputedPropertyName";
|
||||
ComputedPropertyName.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ComputedPropertyName" },
|
||||
{ name: "expression", type: Expression }
|
||||
];
|
||||
|
||||
ConditionalExpression.typeName = "ConditionalExpression";
|
||||
ConditionalExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ConditionalExpression" },
|
||||
{ name: "test", type: Expression },
|
||||
{ name: "consequent", type: Expression },
|
||||
{ name: "alternate", type: Expression }
|
||||
];
|
||||
|
||||
ContinueStatement.typeName = "ContinueStatement";
|
||||
ContinueStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ContinueStatement" },
|
||||
{ name: "label", type: Maybe(STRING) }
|
||||
];
|
||||
|
||||
DataProperty.typeName = "DataProperty";
|
||||
DataProperty.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "DataProperty" },
|
||||
{ name: "name", type: PropertyName },
|
||||
{ name: "expression", type: Expression }
|
||||
];
|
||||
|
||||
DebuggerStatement.typeName = "DebuggerStatement";
|
||||
DebuggerStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "DebuggerStatement" }
|
||||
];
|
||||
|
||||
Directive.typeName = "Directive";
|
||||
Directive.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "Directive" },
|
||||
{ name: "rawValue", type: STRING }
|
||||
];
|
||||
|
||||
DoWhileStatement.typeName = "DoWhileStatement";
|
||||
DoWhileStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "DoWhileStatement" },
|
||||
{ name: "body", type: Statement },
|
||||
{ name: "test", type: Expression }
|
||||
];
|
||||
|
||||
EmptyStatement.typeName = "EmptyStatement";
|
||||
EmptyStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "EmptyStatement" }
|
||||
];
|
||||
|
||||
Export.typeName = "Export";
|
||||
Export.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "Export" },
|
||||
{ name: "declaration", type: Union(ClassDeclaration, FunctionDeclaration, VariableDeclaration) }
|
||||
];
|
||||
|
||||
ExportAllFrom.typeName = "ExportAllFrom";
|
||||
ExportAllFrom.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ExportAllFrom" },
|
||||
{ name: "moduleSpecifier", type: STRING }
|
||||
];
|
||||
|
||||
ExportDefault.typeName = "ExportDefault";
|
||||
ExportDefault.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ExportDefault" },
|
||||
{ name: "body", type: Union(ClassDeclaration, Expression, FunctionDeclaration) }
|
||||
];
|
||||
|
||||
ExportFrom.typeName = "ExportFrom";
|
||||
ExportFrom.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ExportFrom" },
|
||||
{ name: "namedExports", type: List(ExportFromSpecifier) },
|
||||
{ name: "moduleSpecifier", type: STRING }
|
||||
];
|
||||
|
||||
ExportFromSpecifier.typeName = "ExportFromSpecifier";
|
||||
ExportFromSpecifier.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ExportFromSpecifier" },
|
||||
{ name: "name", type: STRING },
|
||||
{ name: "exportedName", type: Maybe(STRING) }
|
||||
];
|
||||
|
||||
ExportLocalSpecifier.typeName = "ExportLocalSpecifier";
|
||||
ExportLocalSpecifier.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ExportLocalSpecifier" },
|
||||
{ name: "name", type: IdentifierExpression },
|
||||
{ name: "exportedName", type: Maybe(STRING) }
|
||||
];
|
||||
|
||||
ExportLocals.typeName = "ExportLocals";
|
||||
ExportLocals.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ExportLocals" },
|
||||
{ name: "namedExports", type: List(ExportLocalSpecifier) }
|
||||
];
|
||||
|
||||
ExpressionStatement.typeName = "ExpressionStatement";
|
||||
ExpressionStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ExpressionStatement" },
|
||||
{ name: "expression", type: Expression }
|
||||
];
|
||||
|
||||
ForAwaitStatement.typeName = "ForAwaitStatement";
|
||||
ForAwaitStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ForAwaitStatement" },
|
||||
{ name: "left", type: Union(Union(Union(ArrayAssignmentTarget, ObjectAssignmentTarget), Union(AssignmentTargetIdentifier, MemberAssignmentTarget)), VariableDeclaration) },
|
||||
{ name: "right", type: Expression },
|
||||
{ name: "body", type: Statement }
|
||||
];
|
||||
|
||||
ForInStatement.typeName = "ForInStatement";
|
||||
ForInStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ForInStatement" },
|
||||
{ name: "left", type: Union(Union(Union(ArrayAssignmentTarget, ObjectAssignmentTarget), Union(AssignmentTargetIdentifier, MemberAssignmentTarget)), VariableDeclaration) },
|
||||
{ name: "right", type: Expression },
|
||||
{ name: "body", type: Statement }
|
||||
];
|
||||
|
||||
ForOfStatement.typeName = "ForOfStatement";
|
||||
ForOfStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ForOfStatement" },
|
||||
{ name: "left", type: Union(Union(Union(ArrayAssignmentTarget, ObjectAssignmentTarget), Union(AssignmentTargetIdentifier, MemberAssignmentTarget)), VariableDeclaration) },
|
||||
{ name: "right", type: Expression },
|
||||
{ name: "body", type: Statement }
|
||||
];
|
||||
|
||||
ForStatement.typeName = "ForStatement";
|
||||
ForStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ForStatement" },
|
||||
{ name: "init", type: Maybe(Union(Expression, VariableDeclaration)) },
|
||||
{ name: "test", type: Maybe(Expression) },
|
||||
{ name: "update", type: Maybe(Expression) },
|
||||
{ name: "body", type: Statement }
|
||||
];
|
||||
|
||||
FormalParameters.typeName = "FormalParameters";
|
||||
FormalParameters.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "FormalParameters" },
|
||||
{ name: "items", type: List(Union(BindingWithDefault, Union(BindingIdentifier, Union(ArrayBinding, ObjectBinding)))) },
|
||||
{ name: "rest", type: Maybe(Union(BindingIdentifier, Union(ArrayBinding, ObjectBinding))) }
|
||||
];
|
||||
|
||||
FunctionBody.typeName = "FunctionBody";
|
||||
FunctionBody.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "FunctionBody" },
|
||||
{ name: "directives", type: List(Directive) },
|
||||
{ name: "statements", type: List(Statement) }
|
||||
];
|
||||
|
||||
FunctionDeclaration.typeName = "FunctionDeclaration";
|
||||
FunctionDeclaration.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "FunctionDeclaration" },
|
||||
{ name: "isAsync", type: BOOLEAN },
|
||||
{ name: "isGenerator", type: BOOLEAN },
|
||||
{ name: "name", type: BindingIdentifier },
|
||||
{ name: "params", type: FormalParameters },
|
||||
{ name: "body", type: FunctionBody }
|
||||
];
|
||||
|
||||
FunctionExpression.typeName = "FunctionExpression";
|
||||
FunctionExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "FunctionExpression" },
|
||||
{ name: "isAsync", type: BOOLEAN },
|
||||
{ name: "isGenerator", type: BOOLEAN },
|
||||
{ name: "name", type: Maybe(BindingIdentifier) },
|
||||
{ name: "params", type: FormalParameters },
|
||||
{ name: "body", type: FunctionBody }
|
||||
];
|
||||
|
||||
Getter.typeName = "Getter";
|
||||
Getter.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "Getter" },
|
||||
{ name: "name", type: PropertyName },
|
||||
{ name: "body", type: FunctionBody }
|
||||
];
|
||||
|
||||
IdentifierExpression.typeName = "IdentifierExpression";
|
||||
IdentifierExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "IdentifierExpression" },
|
||||
{ name: "name", type: STRING }
|
||||
];
|
||||
|
||||
IfStatement.typeName = "IfStatement";
|
||||
IfStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "IfStatement" },
|
||||
{ name: "test", type: Expression },
|
||||
{ name: "consequent", type: Statement },
|
||||
{ name: "alternate", type: Maybe(Statement) }
|
||||
];
|
||||
|
||||
Import.typeName = "Import";
|
||||
Import.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "Import" },
|
||||
{ name: "defaultBinding", type: Maybe(BindingIdentifier) },
|
||||
{ name: "namedImports", type: List(ImportSpecifier) },
|
||||
{ name: "moduleSpecifier", type: STRING }
|
||||
];
|
||||
|
||||
ImportNamespace.typeName = "ImportNamespace";
|
||||
ImportNamespace.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ImportNamespace" },
|
||||
{ name: "defaultBinding", type: Maybe(BindingIdentifier) },
|
||||
{ name: "namespaceBinding", type: BindingIdentifier },
|
||||
{ name: "moduleSpecifier", type: STRING }
|
||||
];
|
||||
|
||||
ImportSpecifier.typeName = "ImportSpecifier";
|
||||
ImportSpecifier.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ImportSpecifier" },
|
||||
{ name: "name", type: Maybe(STRING) },
|
||||
{ name: "binding", type: BindingIdentifier }
|
||||
];
|
||||
|
||||
LabeledStatement.typeName = "LabeledStatement";
|
||||
LabeledStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "LabeledStatement" },
|
||||
{ name: "label", type: STRING },
|
||||
{ name: "body", type: Statement }
|
||||
];
|
||||
|
||||
LiteralBooleanExpression.typeName = "LiteralBooleanExpression";
|
||||
LiteralBooleanExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "LiteralBooleanExpression" },
|
||||
{ name: "value", type: BOOLEAN }
|
||||
];
|
||||
|
||||
LiteralInfinityExpression.typeName = "LiteralInfinityExpression";
|
||||
LiteralInfinityExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "LiteralInfinityExpression" }
|
||||
];
|
||||
|
||||
LiteralNullExpression.typeName = "LiteralNullExpression";
|
||||
LiteralNullExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "LiteralNullExpression" }
|
||||
];
|
||||
|
||||
LiteralNumericExpression.typeName = "LiteralNumericExpression";
|
||||
LiteralNumericExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "LiteralNumericExpression" },
|
||||
{ name: "value", type: DOUBLE }
|
||||
];
|
||||
|
||||
LiteralRegExpExpression.typeName = "LiteralRegExpExpression";
|
||||
LiteralRegExpExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "LiteralRegExpExpression" },
|
||||
{ name: "pattern", type: STRING },
|
||||
{ name: "global", type: BOOLEAN },
|
||||
{ name: "ignoreCase", type: BOOLEAN },
|
||||
{ name: "multiLine", type: BOOLEAN },
|
||||
{ name: "dotAll", type: BOOLEAN },
|
||||
{ name: "unicode", type: BOOLEAN },
|
||||
{ name: "sticky", type: BOOLEAN }
|
||||
];
|
||||
|
||||
LiteralStringExpression.typeName = "LiteralStringExpression";
|
||||
LiteralStringExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "LiteralStringExpression" },
|
||||
{ name: "value", type: STRING }
|
||||
];
|
||||
|
||||
Method.typeName = "Method";
|
||||
Method.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "Method" },
|
||||
{ name: "isAsync", type: BOOLEAN },
|
||||
{ name: "isGenerator", type: BOOLEAN },
|
||||
{ name: "name", type: PropertyName },
|
||||
{ name: "params", type: FormalParameters },
|
||||
{ name: "body", type: FunctionBody }
|
||||
];
|
||||
|
||||
Module.typeName = "Module";
|
||||
Module.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "Module" },
|
||||
{ name: "directives", type: List(Directive) },
|
||||
{ name: "items", type: List(Union(ExportDeclaration, ImportDeclaration, Statement)) }
|
||||
];
|
||||
|
||||
NewExpression.typeName = "NewExpression";
|
||||
NewExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "NewExpression" },
|
||||
{ name: "callee", type: Expression },
|
||||
{ name: "arguments", type: List(Union(Expression, SpreadElement)) }
|
||||
];
|
||||
|
||||
NewTargetExpression.typeName = "NewTargetExpression";
|
||||
NewTargetExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "NewTargetExpression" }
|
||||
];
|
||||
|
||||
ObjectAssignmentTarget.typeName = "ObjectAssignmentTarget";
|
||||
ObjectAssignmentTarget.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ObjectAssignmentTarget" },
|
||||
{ name: "properties", type: List(AssignmentTargetProperty) },
|
||||
{ name: "rest", type: Maybe(Union(Union(ArrayAssignmentTarget, ObjectAssignmentTarget), Union(AssignmentTargetIdentifier, MemberAssignmentTarget))) }
|
||||
];
|
||||
|
||||
ObjectBinding.typeName = "ObjectBinding";
|
||||
ObjectBinding.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ObjectBinding" },
|
||||
{ name: "properties", type: List(BindingProperty) },
|
||||
{ name: "rest", type: Maybe(Union(BindingIdentifier, Union(ArrayBinding, ObjectBinding))) }
|
||||
];
|
||||
|
||||
ObjectExpression.typeName = "ObjectExpression";
|
||||
ObjectExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ObjectExpression" },
|
||||
{ name: "properties", type: List(ObjectProperty) }
|
||||
];
|
||||
|
||||
ReturnStatement.typeName = "ReturnStatement";
|
||||
ReturnStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ReturnStatement" },
|
||||
{ name: "expression", type: Maybe(Expression) }
|
||||
];
|
||||
|
||||
Script.typeName = "Script";
|
||||
Script.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "Script" },
|
||||
{ name: "directives", type: List(Directive) },
|
||||
{ name: "statements", type: List(Statement) }
|
||||
];
|
||||
|
||||
Setter.typeName = "Setter";
|
||||
Setter.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "Setter" },
|
||||
{ name: "name", type: PropertyName },
|
||||
{ name: "param", type: Union(BindingWithDefault, Union(BindingIdentifier, Union(ArrayBinding, ObjectBinding))) },
|
||||
{ name: "body", type: FunctionBody }
|
||||
];
|
||||
|
||||
ShorthandProperty.typeName = "ShorthandProperty";
|
||||
ShorthandProperty.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ShorthandProperty" },
|
||||
{ name: "name", type: IdentifierExpression }
|
||||
];
|
||||
|
||||
SpreadElement.typeName = "SpreadElement";
|
||||
SpreadElement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "SpreadElement" },
|
||||
{ name: "expression", type: Expression }
|
||||
];
|
||||
|
||||
SpreadProperty.typeName = "SpreadProperty";
|
||||
SpreadProperty.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "SpreadProperty" },
|
||||
{ name: "expression", type: Expression }
|
||||
];
|
||||
|
||||
StaticMemberAssignmentTarget.typeName = "StaticMemberAssignmentTarget";
|
||||
StaticMemberAssignmentTarget.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "StaticMemberAssignmentTarget" },
|
||||
{ name: "object", type: Union(Expression, Super) },
|
||||
{ name: "property", type: STRING }
|
||||
];
|
||||
|
||||
StaticMemberExpression.typeName = "StaticMemberExpression";
|
||||
StaticMemberExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "StaticMemberExpression" },
|
||||
{ name: "object", type: Union(Expression, Super) },
|
||||
{ name: "property", type: STRING }
|
||||
];
|
||||
|
||||
StaticPropertyName.typeName = "StaticPropertyName";
|
||||
StaticPropertyName.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "StaticPropertyName" },
|
||||
{ name: "value", type: STRING }
|
||||
];
|
||||
|
||||
Super.typeName = "Super";
|
||||
Super.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "Super" }
|
||||
];
|
||||
|
||||
SwitchCase.typeName = "SwitchCase";
|
||||
SwitchCase.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "SwitchCase" },
|
||||
{ name: "test", type: Expression },
|
||||
{ name: "consequent", type: List(Statement) }
|
||||
];
|
||||
|
||||
SwitchDefault.typeName = "SwitchDefault";
|
||||
SwitchDefault.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "SwitchDefault" },
|
||||
{ name: "consequent", type: List(Statement) }
|
||||
];
|
||||
|
||||
SwitchStatement.typeName = "SwitchStatement";
|
||||
SwitchStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "SwitchStatement" },
|
||||
{ name: "discriminant", type: Expression },
|
||||
{ name: "cases", type: List(SwitchCase) }
|
||||
];
|
||||
|
||||
SwitchStatementWithDefault.typeName = "SwitchStatementWithDefault";
|
||||
SwitchStatementWithDefault.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "SwitchStatementWithDefault" },
|
||||
{ name: "discriminant", type: Expression },
|
||||
{ name: "preDefaultCases", type: List(SwitchCase) },
|
||||
{ name: "defaultCase", type: SwitchDefault },
|
||||
{ name: "postDefaultCases", type: List(SwitchCase) }
|
||||
];
|
||||
|
||||
TemplateElement.typeName = "TemplateElement";
|
||||
TemplateElement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "TemplateElement" },
|
||||
{ name: "rawValue", type: STRING }
|
||||
];
|
||||
|
||||
TemplateExpression.typeName = "TemplateExpression";
|
||||
TemplateExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "TemplateExpression" },
|
||||
{ name: "tag", type: Maybe(Expression) },
|
||||
{ name: "elements", type: List(Union(Expression, TemplateElement)) }
|
||||
];
|
||||
|
||||
ThisExpression.typeName = "ThisExpression";
|
||||
ThisExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ThisExpression" }
|
||||
];
|
||||
|
||||
ThrowStatement.typeName = "ThrowStatement";
|
||||
ThrowStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "ThrowStatement" },
|
||||
{ name: "expression", type: Expression }
|
||||
];
|
||||
|
||||
TryCatchStatement.typeName = "TryCatchStatement";
|
||||
TryCatchStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "TryCatchStatement" },
|
||||
{ name: "body", type: Block },
|
||||
{ name: "catchClause", type: CatchClause }
|
||||
];
|
||||
|
||||
TryFinallyStatement.typeName = "TryFinallyStatement";
|
||||
TryFinallyStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "TryFinallyStatement" },
|
||||
{ name: "body", type: Block },
|
||||
{ name: "catchClause", type: Maybe(CatchClause) },
|
||||
{ name: "finalizer", type: Block }
|
||||
];
|
||||
|
||||
UnaryExpression.typeName = "UnaryExpression";
|
||||
UnaryExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "UnaryExpression" },
|
||||
{ name: "operator", type: UnaryOperator },
|
||||
{ name: "operand", type: Expression }
|
||||
];
|
||||
|
||||
UpdateExpression.typeName = "UpdateExpression";
|
||||
UpdateExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "UpdateExpression" },
|
||||
{ name: "isPrefix", type: BOOLEAN },
|
||||
{ name: "operator", type: UpdateOperator },
|
||||
{ name: "operand", type: Union(AssignmentTargetIdentifier, MemberAssignmentTarget) }
|
||||
];
|
||||
|
||||
VariableDeclaration.typeName = "VariableDeclaration";
|
||||
VariableDeclaration.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "VariableDeclaration" },
|
||||
{ name: "kind", type: VariableDeclarationKind },
|
||||
{ name: "declarators", type: List(VariableDeclarator) }
|
||||
];
|
||||
|
||||
VariableDeclarationStatement.typeName = "VariableDeclarationStatement";
|
||||
VariableDeclarationStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "VariableDeclarationStatement" },
|
||||
{ name: "declaration", type: VariableDeclaration }
|
||||
];
|
||||
|
||||
VariableDeclarator.typeName = "VariableDeclarator";
|
||||
VariableDeclarator.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "VariableDeclarator" },
|
||||
{ name: "binding", type: Union(BindingIdentifier, Union(ArrayBinding, ObjectBinding)) },
|
||||
{ name: "init", type: Maybe(Expression) }
|
||||
];
|
||||
|
||||
WhileStatement.typeName = "WhileStatement";
|
||||
WhileStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "WhileStatement" },
|
||||
{ name: "test", type: Expression },
|
||||
{ name: "body", type: Statement }
|
||||
];
|
||||
|
||||
WithStatement.typeName = "WithStatement";
|
||||
WithStatement.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "WithStatement" },
|
||||
{ name: "object", type: Expression },
|
||||
{ name: "body", type: Statement }
|
||||
];
|
||||
|
||||
YieldExpression.typeName = "YieldExpression";
|
||||
YieldExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "YieldExpression" },
|
||||
{ name: "expression", type: Maybe(Expression) }
|
||||
];
|
||||
|
||||
YieldGeneratorExpression.typeName = "YieldGeneratorExpression";
|
||||
YieldGeneratorExpression.fields = [
|
||||
{ name: "type", type: Const(TYPE_INDICATOR), value: "YieldGeneratorExpression" },
|
||||
{ name: "expression", type: Expression }
|
||||
];
|
||||
|
||||
return SPEC;
|
||||
}());
|
||||
});
|
||||
|
||||
var __pika_web_default_export_for_treeshaking__ = /*@__PURE__*/getDefaultExportFromCjs(dist);
|
||||
|
||||
export default __pika_web_default_export_for_treeshaking__;
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,3 +0,0 @@
|
||||
import { w as webmidi_min } from './common/webmidi.min-97732fd4.js';
|
||||
export { w as default } from './common/webmidi.min-97732fd4.js';
|
||||
import './common/_commonjsHelpers-8c19dec8.js';
|
||||
16
docs/asset-manifest.json
Normal file
16
docs/asset-manifest.json
Normal file
@ -0,0 +1,16 @@
|
||||
{
|
||||
"files": {
|
||||
"main.css": "/static/css/main.0d689283.css",
|
||||
"main.js": "/static/js/main.77e38ada.js",
|
||||
"static/js/787.8f7ec9e0.chunk.js": "/static/js/787.8f7ec9e0.chunk.js",
|
||||
"static/media/logo.svg": "/static/media/logo.ac95051720b3dccfe511e0e02d8e1029.svg",
|
||||
"index.html": "/index.html",
|
||||
"main.0d689283.css.map": "/static/css/main.0d689283.css.map",
|
||||
"main.77e38ada.js.map": "/static/js/main.77e38ada.js.map",
|
||||
"787.8f7ec9e0.chunk.js.map": "/static/js/787.8f7ec9e0.chunk.js.map"
|
||||
},
|
||||
"entrypoints": [
|
||||
"static/css/main.0d689283.css",
|
||||
"static/js/main.77e38ada.js"
|
||||
]
|
||||
}
|
||||
147
docs/dist/App.js
vendored
147
docs/dist/App.js
vendored
@ -1,147 +0,0 @@
|
||||
import React, {useCallback, useLayoutEffect, useRef, useState} from "../_snowpack/pkg/react.js";
|
||||
import CodeMirror, {markEvent, markParens} from "./CodeMirror.js";
|
||||
import cx from "./cx.js";
|
||||
import {evaluate} from "./evaluate.js";
|
||||
import logo from "./logo.svg.proxy.js";
|
||||
import {useWebMidi} from "./midi.js";
|
||||
import playStatic from "./static.js";
|
||||
import {defaultSynth} from "./tone.js";
|
||||
import * as tunes from "./tunes.js";
|
||||
import useRepl from "./useRepl.js";
|
||||
const [_, codeParam] = window.location.href.split("#");
|
||||
let decoded;
|
||||
try {
|
||||
decoded = atob(decodeURIComponent(codeParam || ""));
|
||||
} catch (err) {
|
||||
console.warn("failed to decode", err);
|
||||
}
|
||||
function getRandomTune() {
|
||||
const allTunes = Object.values(tunes);
|
||||
const randomItem = (arr) => arr[Math.floor(Math.random() * arr.length)];
|
||||
return randomItem(allTunes);
|
||||
}
|
||||
const randomTune = getRandomTune();
|
||||
function App() {
|
||||
const [editor, setEditor] = useState();
|
||||
const {setCode, setPattern, error, code, cycle, dirty, log, togglePlay, activateCode, pattern, pushLog, pending} = useRepl({
|
||||
tune: decoded || randomTune,
|
||||
defaultSynth,
|
||||
onDraw: useCallback(markEvent(editor), [editor])
|
||||
});
|
||||
const [uiHidden, setUiHidden] = useState(false);
|
||||
const logBox = useRef();
|
||||
useLayoutEffect(() => {
|
||||
logBox.current.scrollTop = logBox.current?.scrollHeight;
|
||||
}, [log]);
|
||||
useLayoutEffect(() => {
|
||||
const handleKeyPress = async (e) => {
|
||||
if (e.ctrlKey || e.altKey) {
|
||||
switch (e.code) {
|
||||
case "Enter":
|
||||
await activateCode();
|
||||
break;
|
||||
case "Period":
|
||||
cycle.stop();
|
||||
}
|
||||
}
|
||||
};
|
||||
window.addEventListener("keydown", handleKeyPress);
|
||||
return () => window.removeEventListener("keydown", handleKeyPress);
|
||||
}, [pattern, code]);
|
||||
useWebMidi({
|
||||
ready: useCallback(({outputs}) => {
|
||||
pushLog(`WebMidi ready! Just add .midi(${outputs.map((o) => `'${o.name}'`).join(" | ")}) to the pattern. `);
|
||||
}, []),
|
||||
connected: useCallback(({outputs}) => {
|
||||
pushLog(`Midi device connected! Available: ${outputs.map((o) => `'${o.name}'`).join(", ")}`);
|
||||
}, []),
|
||||
disconnected: useCallback(({outputs}) => {
|
||||
pushLog(`Midi device disconnected! Available: ${outputs.map((o) => `'${o.name}'`).join(", ")}`);
|
||||
}, [])
|
||||
});
|
||||
return /* @__PURE__ */ React.createElement("div", {
|
||||
className: "min-h-screen flex flex-col"
|
||||
}, /* @__PURE__ */ React.createElement("header", {
|
||||
id: "header",
|
||||
className: cx("flex-none w-full h-14 px-2 flex border-b border-gray-200 justify-between z-[10]", uiHidden ? "bg-transparent text-white" : "bg-white")
|
||||
}, /* @__PURE__ */ React.createElement("div", {
|
||||
className: "flex items-center space-x-2"
|
||||
}, /* @__PURE__ */ React.createElement("img", {
|
||||
src: logo,
|
||||
className: "Tidal-logo w-12 h-12",
|
||||
alt: "logo"
|
||||
}), /* @__PURE__ */ React.createElement("h1", {
|
||||
className: "text-2xl"
|
||||
}, "Strudel REPL")), /* @__PURE__ */ React.createElement("div", {
|
||||
className: "flex space-x-4"
|
||||
}, /* @__PURE__ */ React.createElement("button", {
|
||||
onClick: () => togglePlay()
|
||||
}, !pending ? /* @__PURE__ */ React.createElement("span", {
|
||||
className: "flex items-center w-16"
|
||||
}, cycle.started ? /* @__PURE__ */ React.createElement("svg", {
|
||||
xmlns: "http://www.w3.org/2000/svg",
|
||||
className: "h-5 w-5",
|
||||
viewBox: "0 0 20 20",
|
||||
fill: "currentColor"
|
||||
}, /* @__PURE__ */ React.createElement("path", {
|
||||
fillRule: "evenodd",
|
||||
d: "M18 10a8 8 0 11-16 0 8 8 0 0116 0zM7 8a1 1 0 012 0v4a1 1 0 11-2 0V8zm5-1a1 1 0 00-1 1v4a1 1 0 102 0V8a1 1 0 00-1-1z",
|
||||
clipRule: "evenodd"
|
||||
})) : /* @__PURE__ */ React.createElement("svg", {
|
||||
xmlns: "http://www.w3.org/2000/svg",
|
||||
className: "h-5 w-5",
|
||||
viewBox: "0 0 20 20",
|
||||
fill: "currentColor"
|
||||
}, /* @__PURE__ */ React.createElement("path", {
|
||||
fillRule: "evenodd",
|
||||
d: "M10 18a8 8 0 100-16 8 8 0 000 16zM9.555 7.168A1 1 0 008 8v4a1 1 0 001.555.832l3-2a1 1 0 000-1.664l-3-2z",
|
||||
clipRule: "evenodd"
|
||||
})), cycle.started ? "pause" : "play") : /* @__PURE__ */ React.createElement(React.Fragment, null, "loading...")), /* @__PURE__ */ React.createElement("button", {
|
||||
onClick: async () => {
|
||||
const _code = getRandomTune();
|
||||
console.log("tune", _code);
|
||||
setCode(_code);
|
||||
const parsed = await evaluate(_code);
|
||||
setPattern(parsed.pattern);
|
||||
}
|
||||
}, "🎲 random"), /* @__PURE__ */ React.createElement("button", null, /* @__PURE__ */ React.createElement("a", {
|
||||
href: "./tutorial"
|
||||
}, "📚 tutorial")), /* @__PURE__ */ React.createElement("button", {
|
||||
onClick: () => setUiHidden((c) => !c)
|
||||
}, "👀 ", uiHidden ? "show ui" : "hide ui"))), /* @__PURE__ */ React.createElement("section", {
|
||||
className: "grow flex flex-col text-gray-100"
|
||||
}, /* @__PURE__ */ React.createElement("div", {
|
||||
className: "grow relative",
|
||||
id: "code"
|
||||
}, /* @__PURE__ */ React.createElement("div", {
|
||||
className: cx("h-full transition-opacity", error ? "focus:ring-red-500" : "focus:ring-slate-800", uiHidden ? "opacity-0" : "opacity-100")
|
||||
}, /* @__PURE__ */ React.createElement(CodeMirror, {
|
||||
value: code,
|
||||
editorDidMount: setEditor,
|
||||
options: {
|
||||
mode: "javascript",
|
||||
theme: "material",
|
||||
lineNumbers: false,
|
||||
styleSelectedText: true,
|
||||
cursorBlinkRate: 0
|
||||
},
|
||||
onCursor: markParens,
|
||||
onChange: (_2, __, value) => setCode(value)
|
||||
}), /* @__PURE__ */ React.createElement("span", {
|
||||
className: "p-4 absolute top-0 right-0 text-xs whitespace-pre text-right pointer-events-none"
|
||||
}, !cycle.started ? `press ctrl+enter to play
|
||||
` : dirty ? `ctrl+enter to update
|
||||
` : "no changes\n")), error && /* @__PURE__ */ React.createElement("div", {
|
||||
className: cx("absolute right-2 bottom-2 px-2", "text-red-500")
|
||||
}, error?.message || "unknown error")), /* @__PURE__ */ React.createElement("textarea", {
|
||||
className: "z-[10] h-16 border-0 text-xs bg-[transparent] border-t border-slate-600 resize-none",
|
||||
value: log,
|
||||
readOnly: true,
|
||||
ref: logBox,
|
||||
style: {fontFamily: "monospace"}
|
||||
})), /* @__PURE__ */ React.createElement("button", {
|
||||
className: "fixed right-4 bottom-2 z-[11]",
|
||||
onClick: () => playStatic(code)
|
||||
}, "static"));
|
||||
}
|
||||
export default App;
|
||||
96
docs/dist/CodeMirror.js
vendored
96
docs/dist/CodeMirror.js
vendored
@ -1,96 +0,0 @@
|
||||
import React from "../_snowpack/pkg/react.js";
|
||||
import {Controlled as CodeMirror2} from "../_snowpack/pkg/react-codemirror2.js";
|
||||
import "../_snowpack/pkg/codemirror/mode/javascript/javascript.js";
|
||||
import "../_snowpack/pkg/codemirror/mode/pegjs/pegjs.js";
|
||||
import "../_snowpack/pkg/codemirror/lib/codemirror.css.proxy.js";
|
||||
import "../_snowpack/pkg/codemirror/theme/material.css.proxy.js";
|
||||
export default function CodeMirror({value, onChange, onCursor, options, editorDidMount}) {
|
||||
options = options || {
|
||||
mode: "javascript",
|
||||
theme: "material",
|
||||
lineNumbers: true,
|
||||
styleSelectedText: true,
|
||||
cursorBlinkRate: 500
|
||||
};
|
||||
return /* @__PURE__ */ React.createElement(CodeMirror2, {
|
||||
value,
|
||||
options,
|
||||
onBeforeChange: onChange,
|
||||
editorDidMount,
|
||||
onCursor: (editor, data) => onCursor?.(editor, data)
|
||||
});
|
||||
}
|
||||
export const markEvent = (editor) => (time, event) => {
|
||||
const locs = event.context.locations;
|
||||
if (!locs || !editor) {
|
||||
return;
|
||||
}
|
||||
const col = event.context?.color || "#FFCA28";
|
||||
const marks = locs.map(({start, end}) => editor.getDoc().markText({line: start.line - 1, ch: start.column}, {line: end.line - 1, ch: end.column}, {css: "outline: 1px solid " + col + "; box-sizing:border-box"}));
|
||||
setTimeout(() => {
|
||||
marks.forEach((mark) => mark.clear());
|
||||
}, event.duration * 1e3);
|
||||
};
|
||||
let parenMark;
|
||||
export const markParens = (editor, data) => {
|
||||
const v = editor.getDoc().getValue();
|
||||
const marked = getCurrentParenArea(v, data);
|
||||
parenMark?.clear();
|
||||
parenMark = editor.getDoc().markText(...marked, {css: "background-color: #00007720"});
|
||||
};
|
||||
export function offsetToPosition(offset, code) {
|
||||
const lines = code.split("\n");
|
||||
let line = 0;
|
||||
let ch = 0;
|
||||
for (let i = 0; i < offset; i++) {
|
||||
if (ch === lines[line].length) {
|
||||
line++;
|
||||
ch = 0;
|
||||
} else {
|
||||
ch++;
|
||||
}
|
||||
}
|
||||
return {line, ch};
|
||||
}
|
||||
export function positionToOffset(position, code) {
|
||||
const lines = code.split("\n");
|
||||
let offset = 0;
|
||||
for (let i = 0; i < position.line; i++) {
|
||||
offset += lines[i].length + 1;
|
||||
}
|
||||
offset += position.ch;
|
||||
return offset;
|
||||
}
|
||||
export function getCurrentParenArea(code, caretPosition) {
|
||||
const caret = positionToOffset(caretPosition, code);
|
||||
let open, i, begin, end;
|
||||
i = caret;
|
||||
open = 0;
|
||||
while (i > 0) {
|
||||
if (code[i - 1] === "(") {
|
||||
open--;
|
||||
} else if (code[i - 1] === ")") {
|
||||
open++;
|
||||
}
|
||||
if (open === -1) {
|
||||
break;
|
||||
}
|
||||
i--;
|
||||
}
|
||||
begin = i;
|
||||
i = caret;
|
||||
open = 0;
|
||||
while (i < code.length) {
|
||||
if (code[i] === "(") {
|
||||
open--;
|
||||
} else if (code[i] === ")") {
|
||||
open++;
|
||||
}
|
||||
if (open === 1) {
|
||||
break;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
end = i;
|
||||
return [begin, end].map((o) => offsetToPosition(o, code));
|
||||
}
|
||||
3
docs/dist/cx.js
vendored
3
docs/dist/cx.js
vendored
@ -1,3 +0,0 @@
|
||||
export default function cx(...classes) {
|
||||
return classes.filter(Boolean).join(" ");
|
||||
}
|
||||
47
docs/dist/draw.js
vendored
47
docs/dist/draw.js
vendored
@ -1,47 +0,0 @@
|
||||
import * as Tone from "../_snowpack/pkg/tone.js";
|
||||
import {Pattern} from "../_snowpack/link/strudel.js";
|
||||
export const getDrawContext = (id = "test-canvas") => {
|
||||
let canvas = document.querySelector("#" + id);
|
||||
if (!canvas) {
|
||||
canvas = document.createElement("canvas");
|
||||
canvas.id = id;
|
||||
canvas.width = window.innerWidth;
|
||||
canvas.height = window.innerHeight;
|
||||
canvas.style = "pointer-events:none;width:100%;height:100%;position:fixed;top:0;left:0;z-index:5";
|
||||
document.body.prepend(canvas);
|
||||
}
|
||||
return canvas.getContext("2d");
|
||||
};
|
||||
Pattern.prototype.draw = function(callback, cycleSpan, lookaheadCycles = 1) {
|
||||
if (window.strudelAnimation) {
|
||||
cancelAnimationFrame(window.strudelAnimation);
|
||||
}
|
||||
const ctx = getDrawContext();
|
||||
let cycle, events = [];
|
||||
const animate = (time) => {
|
||||
const t = Tone.getTransport().seconds;
|
||||
if (cycleSpan) {
|
||||
const currentCycle = Math.floor(t / cycleSpan);
|
||||
if (cycle !== currentCycle) {
|
||||
cycle = currentCycle;
|
||||
const begin = currentCycle * cycleSpan;
|
||||
const end = (currentCycle + lookaheadCycles) * cycleSpan;
|
||||
events = this._asNumber(true).query(new State(new TimeSpan(begin, end))).filter((event) => event.part.begin.equals(event.whole.begin));
|
||||
}
|
||||
}
|
||||
callback(ctx, events, t, cycleSpan, time);
|
||||
window.strudelAnimation = requestAnimationFrame(animate);
|
||||
};
|
||||
requestAnimationFrame(animate);
|
||||
return this;
|
||||
};
|
||||
export const cleanup = () => {
|
||||
const ctx = getDrawContext();
|
||||
ctx.clearRect(0, 0, window.innerWidth, window.innerHeight);
|
||||
if (window.strudelAnimation) {
|
||||
cancelAnimationFrame(window.strudelAnimation);
|
||||
}
|
||||
if (window.strudelScheduler) {
|
||||
clearInterval(window.strudelScheduler);
|
||||
}
|
||||
};
|
||||
21
docs/dist/euclid.js
vendored
21
docs/dist/euclid.js
vendored
@ -1,21 +0,0 @@
|
||||
import {Pattern, timeCat} from "../_snowpack/link/strudel.js";
|
||||
import bjork from "../_snowpack/pkg/bjork.js";
|
||||
import {rotate} from "../_snowpack/link/util.js";
|
||||
import Fraction from "../_snowpack/link/fraction.js";
|
||||
const euclid = (pulses, steps, rotation = 0) => {
|
||||
const b = bjork(steps, pulses);
|
||||
if (rotation) {
|
||||
return rotate(b, -rotation);
|
||||
}
|
||||
return b;
|
||||
};
|
||||
Pattern.prototype.euclid = function(pulses, steps, rotation = 0) {
|
||||
return this.struct(euclid(pulses, steps, rotation));
|
||||
};
|
||||
Pattern.prototype.euclidLegato = function(pulses, steps, rotation = 0) {
|
||||
const bin_pat = euclid(pulses, steps, rotation);
|
||||
const firstOne = bin_pat.indexOf(1);
|
||||
const gapless = rotate(bin_pat, firstOne).join("").split("1").slice(1).map((s) => [s.length + 1, true]);
|
||||
return this.struct(timeCat(...gapless)).late(Fraction(firstOne).div(steps));
|
||||
};
|
||||
export default euclid;
|
||||
47
docs/dist/evaluate.js
vendored
47
docs/dist/evaluate.js
vendored
@ -1,47 +0,0 @@
|
||||
import * as strudel from "../_snowpack/link/strudel.js";
|
||||
import "./tone.js";
|
||||
import "./midi.js";
|
||||
import "./voicings.js";
|
||||
import "./tonal.js";
|
||||
import "./xen.js";
|
||||
import "./tune.js";
|
||||
import "./euclid.js";
|
||||
import euclid from "./euclid.js";
|
||||
import "./pianoroll.js";
|
||||
import "./draw.js";
|
||||
import * as uiHelpers from "./ui.js";
|
||||
import * as drawHelpers from "./draw.js";
|
||||
import gist from "./gist.js";
|
||||
import shapeshifter from "./shapeshifter.js";
|
||||
import {mini} from "./parse.js";
|
||||
import * as Tone from "../_snowpack/pkg/tone.js";
|
||||
import * as toneHelpers from "./tone.js";
|
||||
import * as voicingHelpers from "./voicings.js";
|
||||
const bootstrapped = {...strudel, ...strudel.Pattern.prototype.bootstrap()};
|
||||
function hackLiteral(literal, names, func) {
|
||||
names.forEach((name) => {
|
||||
Object.defineProperty(literal.prototype, name, {
|
||||
get: function() {
|
||||
return func(String(this));
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
hackLiteral(String, ["mini", "m"], bootstrapped.mini);
|
||||
hackLiteral(String, ["pure", "p"], bootstrapped.pure);
|
||||
Object.assign(globalThis, Tone, bootstrapped, toneHelpers, voicingHelpers, drawHelpers, uiHelpers, {
|
||||
gist,
|
||||
euclid,
|
||||
mini
|
||||
});
|
||||
export const evaluate = async (code) => {
|
||||
const shapeshifted = shapeshifter(code);
|
||||
drawHelpers.cleanup();
|
||||
uiHelpers.cleanup();
|
||||
let evaluated = await eval(shapeshifted);
|
||||
if (evaluated?.constructor?.name !== "Pattern") {
|
||||
const message = `got "${typeof evaluated}" instead of pattern`;
|
||||
throw new Error(message + (typeof evaluated === "function" ? ", did you forget to call a function?" : "."));
|
||||
}
|
||||
return {mode: "javascript", pattern: evaluated};
|
||||
};
|
||||
6
docs/dist/gist.js
vendored
6
docs/dist/gist.js
vendored
@ -1,6 +0,0 @@
|
||||
// this is a shortcut to eval code from a gist
|
||||
// why? to be able to shorten strudel code + e.g. be able to change instruments after links have been generated
|
||||
export default (route) =>
|
||||
fetch(`https://gist.githubusercontent.com/${route}?cachebust=${Date.now()}`)
|
||||
.then((res) => res.text())
|
||||
.then((code) => eval(code));
|
||||
10
docs/dist/index.js
vendored
10
docs/dist/index.js
vendored
@ -1,10 +0,0 @@
|
||||
import * as __SNOWPACK_ENV__ from '../_snowpack/env.js';
|
||||
import.meta.env = __SNOWPACK_ENV__;
|
||||
|
||||
import React from "../_snowpack/pkg/react.js";
|
||||
import ReactDOM from "../_snowpack/pkg/react-dom.js";
|
||||
import App from "./App.js";
|
||||
ReactDOM.render(/* @__PURE__ */ React.createElement(React.StrictMode, null, /* @__PURE__ */ React.createElement(App, null)), document.getElementById("root"));
|
||||
if (undefined /* [snowpack] import.meta.hot */ ) {
|
||||
undefined /* [snowpack] import.meta.hot */ .accept();
|
||||
}
|
||||
1
docs/dist/logo.svg.proxy.js
vendored
1
docs/dist/logo.svg.proxy.js
vendored
@ -1 +0,0 @@
|
||||
export default "/dist/logo.svg";
|
||||
87
docs/dist/midi.js
vendored
87
docs/dist/midi.js
vendored
@ -1,87 +0,0 @@
|
||||
import {useEffect, useState} from "../_snowpack/pkg/react.js";
|
||||
import {isNote} from "../_snowpack/pkg/tone.js";
|
||||
import _WebMidi from "../_snowpack/pkg/webmidi.js";
|
||||
import {Pattern as _Pattern} from "../_snowpack/link/strudel.js";
|
||||
import * as Tone from "../_snowpack/pkg/tone.js";
|
||||
const WebMidi = _WebMidi;
|
||||
const Pattern = _Pattern;
|
||||
export default function enableWebMidi() {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (WebMidi.enabled) {
|
||||
resolve(WebMidi);
|
||||
return;
|
||||
}
|
||||
WebMidi.enable((err) => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
}
|
||||
resolve(WebMidi);
|
||||
});
|
||||
});
|
||||
}
|
||||
const outputByName = (name) => WebMidi.getOutputByName(name);
|
||||
Pattern.prototype.midi = function(output, channel = 1) {
|
||||
if (output?.constructor?.name === "Pattern") {
|
||||
throw new Error(`.midi does not accept Pattern input. Make sure to pass device name with single quotes. Example: .midi('${WebMidi.outputs?.[0]?.name || "IAC Driver Bus 1"}')`);
|
||||
}
|
||||
return this._withEvent((event) => {
|
||||
const onTrigger = (time, event2) => {
|
||||
let note = event2.value;
|
||||
const velocity = event2.context?.velocity ?? 0.9;
|
||||
if (!isNote(note)) {
|
||||
throw new Error("not a note: " + note);
|
||||
}
|
||||
if (!WebMidi.enabled) {
|
||||
throw new Error(`🎹 WebMidi is not enabled. Supported Browsers: https://caniuse.com/?search=webmidi`);
|
||||
}
|
||||
if (!WebMidi.outputs.length) {
|
||||
throw new Error(`🔌 No MIDI devices found. Connect a device or enable IAC Driver.`);
|
||||
}
|
||||
let device;
|
||||
if (typeof output === "number") {
|
||||
device = WebMidi.outputs[output];
|
||||
} else if (typeof output === "string") {
|
||||
device = outputByName(output);
|
||||
} else {
|
||||
device = WebMidi.outputs[0];
|
||||
}
|
||||
if (!device) {
|
||||
throw new Error(`🔌 MIDI device '${output ? output : ""}' not found. Use one of ${WebMidi.outputs.map((o) => `'${o.name}'`).join(" | ")}`);
|
||||
}
|
||||
const timingOffset = WebMidi.time - Tone.context.currentTime * 1e3;
|
||||
time = time * 1e3 + timingOffset;
|
||||
device.playNote(note, channel, {
|
||||
time,
|
||||
duration: event2.duration * 1e3 - 5,
|
||||
velocity
|
||||
});
|
||||
};
|
||||
return event.setContext({...event.context, onTrigger});
|
||||
});
|
||||
};
|
||||
export function useWebMidi(props) {
|
||||
const {ready, connected, disconnected} = props;
|
||||
const [loading, setLoading] = useState(true);
|
||||
const [outputs, setOutputs] = useState(WebMidi?.outputs || []);
|
||||
useEffect(() => {
|
||||
enableWebMidi().then(() => {
|
||||
WebMidi.addListener("connected", (e) => {
|
||||
setOutputs([...WebMidi.outputs]);
|
||||
connected?.(WebMidi, e);
|
||||
});
|
||||
WebMidi.addListener("disconnected", (e) => {
|
||||
setOutputs([...WebMidi.outputs]);
|
||||
disconnected?.(WebMidi, e);
|
||||
});
|
||||
ready?.(WebMidi);
|
||||
setLoading(false);
|
||||
}).catch((err) => {
|
||||
if (err) {
|
||||
console.warn("Web Midi could not be enabled..");
|
||||
return;
|
||||
}
|
||||
});
|
||||
}, [ready, connected, disconnected, outputs]);
|
||||
const outputByName2 = (name) => WebMidi.getOutputByName(name);
|
||||
return {loading, outputs, outputByName: outputByName2};
|
||||
}
|
||||
151
docs/dist/oldtunes.js
vendored
151
docs/dist/oldtunes.js
vendored
@ -1,151 +0,0 @@
|
||||
export const timeCatMini = `stack(
|
||||
"c3@3 [eb3, g3, [c4 d4]/2]",
|
||||
"c2 g2",
|
||||
"[eb4@5 [f4 eb4 d4]@3] [eb4 c4]/2".slow(8)
|
||||
)`;
|
||||
export const timeCat = `stack(
|
||||
timeCat([3, c3], [1, stack(eb3, g3, cat(c4, d4).slow(2))]),
|
||||
cat(c2, g2),
|
||||
sequence(
|
||||
timeCat([5, eb4], [3, cat(f4, eb4, d4)]),
|
||||
cat(eb4, c4).slow(2)
|
||||
).slow(4)
|
||||
)`;
|
||||
export const shapeShifted = `stack(
|
||||
sequence(
|
||||
e5, [b4, c5], d5, [c5, b4],
|
||||
a4, [a4, c5], e5, [d5, c5],
|
||||
b4, [r, c5], d5, e5,
|
||||
c5, a4, a4, r,
|
||||
[r, d5], [r, f5], a5, [g5, f5],
|
||||
e5, [r, c5], e5, [d5, c5],
|
||||
b4, [b4, c5], d5, e5,
|
||||
c5, a4, a4, r,
|
||||
).rev(),
|
||||
sequence(
|
||||
e2, e3, e2, e3, e2, e3, e2, e3,
|
||||
a2, a3, a2, a3, a2, a3, a2, a3,
|
||||
gs2, gs3, gs2, gs3, e2, e3, e2, e3,
|
||||
a2, a3, a2, a3, a2, a3, b1, c2,
|
||||
d2, d3, d2, d3, d2, d3, d2, d3,
|
||||
c2, c3, c2, c3, c2, c3, c2, c3,
|
||||
b1, b2, b1, b2, e2, e3, e2, e3,
|
||||
a1, a2, a1, a2, a1, a2, a1, a2,
|
||||
).rev()
|
||||
).slow(16)`;
|
||||
export const tetrisWithFunctions = `stack(sequence(
|
||||
'e5', sequence('b4', 'c5'), 'd5', sequence('c5', 'b4'),
|
||||
'a4', sequence('a4', 'c5'), 'e5', sequence('d5', 'c5'),
|
||||
'b4', sequence(silence, 'c5'), 'd5', 'e5',
|
||||
'c5', 'a4', 'a4', silence,
|
||||
sequence(silence, 'd5'), sequence(silence, 'f5'), 'a5', sequence('g5', 'f5'),
|
||||
'e5', sequence(silence, 'c5'), 'e5', sequence('d5', 'c5'),
|
||||
'b4', sequence('b4', 'c5'), 'd5', 'e5',
|
||||
'c5', 'a4', 'a4', silence),
|
||||
sequence(
|
||||
'e2', 'e3', 'e2', 'e3', 'e2', 'e3', 'e2', 'e3',
|
||||
'a2', 'a3', 'a2', 'a3', 'a2', 'a3', 'a2', 'a3',
|
||||
'g#2', 'g#3', 'g#2', 'g#3', 'e2', 'e3', 'e2', 'e3',
|
||||
'a2', 'a3', 'a2', 'a3', 'a2', 'a3', 'b1', 'c2',
|
||||
'd2', 'd3', 'd2', 'd3', 'd2', 'd3', 'd2', 'd3',
|
||||
'c2', 'c3', 'c2', 'c3', 'c2', 'c3', 'c2', 'c3',
|
||||
'b1', 'b2', 'b1', 'b2', 'e2', 'e3', 'e2', 'e3',
|
||||
'a1', 'a2', 'a1', 'a2', 'a1', 'a2', 'a1', 'a2',
|
||||
)
|
||||
).slow(16)`;
|
||||
export const tetris = `stack(
|
||||
cat(
|
||||
"e5 [b4 c5] d5 [c5 b4]",
|
||||
"a4 [a4 c5] e5 [d5 c5]",
|
||||
"b4 [~ c5] d5 e5",
|
||||
"c5 a4 a4 ~",
|
||||
"[~ d5] [~ f5] a5 [g5 f5]",
|
||||
"e5 [~ c5] e5 [d5 c5]",
|
||||
"b4 [b4 c5] d5 e5",
|
||||
"c5 a4 a4 ~"
|
||||
),
|
||||
cat(
|
||||
"e2 e3 e2 e3 e2 e3 e2 e3",
|
||||
"a2 a3 a2 a3 a2 a3 a2 a3",
|
||||
"g#2 g#3 g#2 g#3 e2 e3 e2 e3",
|
||||
"a2 a3 a2 a3 a2 a3 b1 c2",
|
||||
"d2 d3 d2 d3 d2 d3 d2 d3",
|
||||
"c2 c3 c2 c3 c2 c3 c2 c3",
|
||||
"b1 b2 b1 b2 e2 e3 e2 e3",
|
||||
"a1 a2 a1 a2 a1 a2 a1 a2",
|
||||
)
|
||||
).slow(16)`;
|
||||
export const tetrisMini = `\`[[e5 [b4 c5] d5 [c5 b4]]
|
||||
[a4 [a4 c5] e5 [d5 c5]]
|
||||
[b4 [~ c5] d5 e5]
|
||||
[c5 a4 a4 ~]
|
||||
[[~ d5] [~ f5] a5 [g5 f5]]
|
||||
[e5 [~ c5] e5 [d5 c5]]
|
||||
[b4 [b4 c5] d5 e5]
|
||||
[c5 a4 a4 ~]],
|
||||
[[e2 e3]*4]
|
||||
[[a2 a3]*4]
|
||||
[[g#2 g#3]*2 [e2 e3]*2]
|
||||
[a2 a3 a2 a3 a2 a3 b1 c2]
|
||||
[[d2 d3]*4]
|
||||
[[c2 c3]*4]
|
||||
[[b1 b2]*2 [e2 e3]*2]
|
||||
[[a1 a2]*4]\`.slow(16)
|
||||
`;
|
||||
export const whirlyStrudel = `sequence(e4, [b2, b3], c4)
|
||||
.every(4, fast(2))
|
||||
.every(3, slow(1.5))
|
||||
.fast(slowcat(1.25, 1, 1.5))
|
||||
.every(2, _ => sequence(e4, r, e3, d4, r))`;
|
||||
export const giantSteps = `stack(
|
||||
// melody
|
||||
cat(
|
||||
"[F#5 D5] [B4 G4] Bb4 [B4 A4]",
|
||||
"[D5 Bb4] [G4 Eb4] F#4 [G4 F4]",
|
||||
"Bb4 [B4 A4] D5 [D#5 C#5]",
|
||||
"F#5 [G5 F5] Bb5 [F#5 F#5]",
|
||||
),
|
||||
// chords
|
||||
cat(
|
||||
"[B^7 D7] [G^7 Bb7] Eb^7 [Am7 D7]",
|
||||
"[G^7 Bb7] [Eb^7 F#7] B^7 [Fm7 Bb7]",
|
||||
"Eb^7 [Am7 D7] G^7 [C#m7 F#7]",
|
||||
"B^7 [Fm7 Bb7] Eb^7 [C#m7 F#7]"
|
||||
).voicings(['E3', 'G4']),
|
||||
// bass
|
||||
cat(
|
||||
"[B2 D2] [G2 Bb2] [Eb2 Bb3] [A2 D2]",
|
||||
"[G2 Bb2] [Eb2 F#2] [B2 F#2] [F2 Bb2]",
|
||||
"[Eb2 Bb2] [A2 D2] [G2 D2] [C#2 F#2]",
|
||||
"[B2 F#2] [F2 Bb2] [Eb2 Bb3] [C#2 F#2]"
|
||||
)
|
||||
).slow(20);`;
|
||||
export const transposedChordsHacked = `stack(
|
||||
"c2 eb2 g2",
|
||||
"Cm7".voicings(['g2','c4']).slow(2)
|
||||
).transpose(
|
||||
slowcat(1, 2, 3, 2).slow(2)
|
||||
).transpose(5)`;
|
||||
export const scaleTranspose = `stack(f2, f3, c4, ab4)
|
||||
.scale(sequence('F minor', 'F harmonic minor').slow(4))
|
||||
.scaleTranspose(sequence(0, -1, -2, -3).slow(4))
|
||||
.transpose(sequence(0, 1).slow(16))`;
|
||||
export const struct = `stack(
|
||||
"c2 g2 a2 [e2@2 eb2] d2 a2 g2 [d2 ~ db2]",
|
||||
"[C^7 A7] [Dm7 G7]".struct("[x@2 x] [~@2 x] [~ x@2]@2 [x ~@2] ~ [~@2 x@4]@2")
|
||||
.voicings(['G3','A4'])
|
||||
).slow(4)`;
|
||||
export const magicSofa = `stack(
|
||||
"<C^7 F^7 ~> <Dm7 G7 A7 ~>"
|
||||
.every(2, fast(2))
|
||||
.voicings(),
|
||||
"<c2 f2 g2> <d2 g2 a2 e2>"
|
||||
).slow(1).transpose.slowcat(0, 2, 3, 4)`;
|
||||
export const primalEnemy = `()=>{
|
||||
const f = fast("<1 <2 [4 8]>>");
|
||||
return stack(
|
||||
"c3,g3,c4".struct("[x ~]*2").apply(f).transpose("<0 <3 [5 [7 [9 [11 13]]]]>>"),
|
||||
"c2 [c2 ~]*2".tone(synth(osc('sawtooth8')).chain(vol(0.8),out())),
|
||||
"c1*2".tone(membrane().chain(vol(0.8),out()))
|
||||
).slow(1)
|
||||
}`;
|
||||
149
docs/dist/parse.js
vendored
149
docs/dist/parse.js
vendored
@ -1,149 +0,0 @@
|
||||
import * as krill from "../_snowpack/link/repl/krill-parser.js";
|
||||
import * as strudel from "../_snowpack/link/strudel.js";
|
||||
import {Scale, Note, Interval} from "../_snowpack/pkg/@tonaljs/tonal.js";
|
||||
import {addMiniLocations} from "./shapeshifter.js";
|
||||
const {pure, Pattern, Fraction, stack, slowcat, sequence, timeCat, silence} = strudel;
|
||||
const applyOptions = (parent) => (pat, i) => {
|
||||
const ast = parent.source_[i];
|
||||
const options = ast.options_;
|
||||
const operator = options?.operator;
|
||||
if (operator) {
|
||||
switch (operator.type_) {
|
||||
case "stretch":
|
||||
const speed = Fraction(operator.arguments_.amount).inverse();
|
||||
return reify(pat).fast(speed);
|
||||
case "bjorklund":
|
||||
return pat.euclid(operator.arguments_.pulse, operator.arguments_.step, operator.arguments_.rotation);
|
||||
}
|
||||
console.warn(`operator "${operator.type_}" not implemented`);
|
||||
}
|
||||
if (options?.weight) {
|
||||
return pat;
|
||||
}
|
||||
const unimplemented = Object.keys(options || {}).filter((key) => key !== "operator");
|
||||
if (unimplemented.length) {
|
||||
console.warn(`option${unimplemented.length > 1 ? "s" : ""} ${unimplemented.map((o) => `"${o}"`).join(", ")} not implemented`);
|
||||
}
|
||||
return pat;
|
||||
};
|
||||
function resolveReplications(ast) {
|
||||
ast.source_ = ast.source_.map((child) => {
|
||||
const {replicate, ...options} = child.options_ || {};
|
||||
if (replicate) {
|
||||
return {
|
||||
...child,
|
||||
options_: {...options, weight: replicate},
|
||||
source_: {
|
||||
type_: "pattern",
|
||||
arguments_: {
|
||||
alignment: "h"
|
||||
},
|
||||
source_: [
|
||||
{
|
||||
type_: "element",
|
||||
source_: child.source_,
|
||||
location_: child.location_,
|
||||
options_: {
|
||||
operator: {
|
||||
type_: "stretch",
|
||||
arguments_: {amount: Fraction(replicate).inverse().toString()}
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
};
|
||||
}
|
||||
return child;
|
||||
});
|
||||
}
|
||||
export function patternifyAST(ast) {
|
||||
switch (ast.type_) {
|
||||
case "pattern":
|
||||
resolveReplications(ast);
|
||||
const children = ast.source_.map(patternifyAST).map(applyOptions(ast));
|
||||
const alignment = ast.arguments_.alignment;
|
||||
if (alignment === "v") {
|
||||
return stack(...children);
|
||||
}
|
||||
const weightedChildren = ast.source_.some((child) => !!child.options_?.weight);
|
||||
if (!weightedChildren && alignment === "t") {
|
||||
return slowcat(...children);
|
||||
}
|
||||
if (weightedChildren) {
|
||||
const pat = timeCat(...ast.source_.map((child, i) => [child.options_?.weight || 1, children[i]]));
|
||||
if (alignment === "t") {
|
||||
const weightSum = ast.source_.reduce((sum, child) => sum + (child.options_?.weight || 1), 0);
|
||||
return pat._slow(weightSum);
|
||||
}
|
||||
return pat;
|
||||
}
|
||||
return sequence(...children);
|
||||
case "element":
|
||||
if (ast.source_ === "~") {
|
||||
return silence;
|
||||
}
|
||||
if (typeof ast.source_ !== "object") {
|
||||
if (!addMiniLocations) {
|
||||
return ast.source_;
|
||||
}
|
||||
if (!ast.location_) {
|
||||
console.warn("no location for", ast);
|
||||
return ast.source_;
|
||||
}
|
||||
const {start, end} = ast.location_;
|
||||
const value = !isNaN(Number(ast.source_)) ? Number(ast.source_) : ast.source_;
|
||||
return pure(value).withLocation([start.line, start.column, start.offset], [end.line, end.column, end.offset]);
|
||||
}
|
||||
return patternifyAST(ast.source_);
|
||||
case "stretch":
|
||||
return patternifyAST(ast.source_).slow(ast.arguments_.amount);
|
||||
case "scale":
|
||||
let [tonic, scale] = Scale.tokenize(ast.arguments_.scale);
|
||||
const intervals = Scale.get(scale).intervals;
|
||||
const pattern = patternifyAST(ast.source_);
|
||||
tonic = tonic || "C4";
|
||||
console.log("tonic", tonic);
|
||||
return pattern.fmap((step) => {
|
||||
step = Number(step);
|
||||
if (isNaN(step)) {
|
||||
console.warn(`scale step "${step}" not a number`);
|
||||
return step;
|
||||
}
|
||||
const octaves = Math.floor(step / intervals.length);
|
||||
const mod = (n, m) => n < 0 ? mod(n + m, m) : n % m;
|
||||
const index = mod(step, intervals.length);
|
||||
const interval = Interval.add(intervals[index], Interval.fromSemitones(octaves * 12));
|
||||
return Note.transpose(tonic, interval || "1P");
|
||||
});
|
||||
default:
|
||||
console.warn(`node type "${ast.type_}" not implemented -> returning silence`);
|
||||
return silence;
|
||||
}
|
||||
}
|
||||
export const mini = (...strings) => {
|
||||
const pats = strings.map((str) => {
|
||||
const ast = krill.parse(`"${str}"`);
|
||||
return patternifyAST(ast);
|
||||
});
|
||||
return sequence(...pats);
|
||||
};
|
||||
export const h = (string) => {
|
||||
const ast = krill.parse(string);
|
||||
return patternifyAST(ast);
|
||||
};
|
||||
Pattern.prototype.define("mini", mini, {composable: true});
|
||||
Pattern.prototype.define("m", mini, {composable: true});
|
||||
Pattern.prototype.define("h", h, {composable: true});
|
||||
export function reify(thing) {
|
||||
if (thing?.constructor?.name === "Pattern") {
|
||||
return thing;
|
||||
}
|
||||
return pure(thing);
|
||||
}
|
||||
export function minify(thing) {
|
||||
if (typeof thing === "string") {
|
||||
return mini(thing);
|
||||
}
|
||||
return reify(thing);
|
||||
}
|
||||
33
docs/dist/pianoroll.js
vendored
33
docs/dist/pianoroll.js
vendored
@ -1,33 +0,0 @@
|
||||
import {Pattern} from "../_snowpack/link/strudel.js";
|
||||
Pattern.prototype.pianoroll = function({
|
||||
timeframe = 10,
|
||||
inactive = "#C9E597",
|
||||
active = "#FFCA28",
|
||||
background = "#2A3236",
|
||||
maxMidi = 90,
|
||||
minMidi = 0
|
||||
} = {}) {
|
||||
const w = window.innerWidth;
|
||||
const h = window.innerHeight;
|
||||
const midiRange = maxMidi - minMidi + 1;
|
||||
const height = h / midiRange;
|
||||
this.draw((ctx, events, t) => {
|
||||
ctx.fillStyle = background;
|
||||
ctx.clearRect(0, 0, w, h);
|
||||
ctx.fillRect(0, 0, w, h);
|
||||
events.forEach((event) => {
|
||||
const isActive = event.whole.begin <= t && event.whole.end >= t;
|
||||
ctx.fillStyle = event.context?.color || inactive;
|
||||
ctx.strokeStyle = event.context?.color || active;
|
||||
ctx.globalAlpha = event.context.velocity ?? 1;
|
||||
const x = Math.round(event.whole.begin / timeframe * w);
|
||||
const width = Math.round((event.whole.end - event.whole.begin) / timeframe * w);
|
||||
const y = Math.round(h - (Number(event.value) - minMidi) / midiRange * h);
|
||||
const offset = t / timeframe * w;
|
||||
const margin = 0;
|
||||
const coords = [x - offset + margin + 1, y + 1, width - 2, height - 2];
|
||||
isActive ? ctx.strokeRect(...coords) : ctx.fillRect(...coords);
|
||||
});
|
||||
}, timeframe, 2);
|
||||
return this;
|
||||
};
|
||||
261
docs/dist/shapeshifter.js
vendored
261
docs/dist/shapeshifter.js
vendored
@ -1,261 +0,0 @@
|
||||
import { parseScriptWithLocation } from './shift-parser/index.js'; // npm module does not work in the browser
|
||||
import traverser from './shift-traverser/index.js'; // npm module does not work in the browser
|
||||
const { replace } = traverser;
|
||||
import {
|
||||
LiteralStringExpression,
|
||||
IdentifierExpression,
|
||||
CallExpression,
|
||||
StaticMemberExpression,
|
||||
ReturnStatement,
|
||||
ArrayExpression,
|
||||
LiteralNumericExpression,
|
||||
} from '../_snowpack/pkg/shift-ast.js';
|
||||
import codegen from '../_snowpack/pkg/shift-codegen.js';
|
||||
import * as strudel from '../_snowpack/link/strudel.js';
|
||||
|
||||
const { Pattern } = strudel;
|
||||
|
||||
const isNote = (name) => /^[a-gC-G][bs]?[0-9]$/.test(name);
|
||||
|
||||
const addLocations = true;
|
||||
export const addMiniLocations = true;
|
||||
|
||||
export default (_code) => {
|
||||
const { code, addReturn } = wrapAsync(_code);
|
||||
const ast = parseScriptWithLocation(code);
|
||||
const artificialNodes = [];
|
||||
const parents = [];
|
||||
const shifted = replace(ast.tree, {
|
||||
enter(node, parent) {
|
||||
parents.push(parent);
|
||||
const isSynthetic = parents.some((p) => artificialNodes.includes(p));
|
||||
if (isSynthetic) {
|
||||
return node;
|
||||
}
|
||||
|
||||
// replace template string `xxx` with mini(`xxx`)
|
||||
if (isBackTickString(node)) {
|
||||
return minifyWithLocation(node, node, ast.locations, artificialNodes);
|
||||
}
|
||||
// allows to use top level strings, which are normally directives... but we don't need directives
|
||||
if (node.directives?.length === 1 && !node.statements?.length) {
|
||||
const str = new LiteralStringExpression({ value: node.directives[0].rawValue });
|
||||
const wrapped = minifyWithLocation(str, node.directives[0], ast.locations, artificialNodes);
|
||||
return { ...node, directives: [], statements: [wrapped] };
|
||||
}
|
||||
|
||||
// replace double quote string "xxx" with mini('xxx')
|
||||
if (isStringWithDoubleQuotes(node, ast.locations, code)) {
|
||||
return minifyWithLocation(node, node, ast.locations, artificialNodes);
|
||||
}
|
||||
|
||||
// operator overloading => still not done
|
||||
const operators = {
|
||||
'*': 'fast',
|
||||
'/': 'slow',
|
||||
'&': 'stack',
|
||||
'&&': 'append',
|
||||
};
|
||||
if (
|
||||
node.type === 'BinaryExpression' &&
|
||||
operators[node.operator] &&
|
||||
['LiteralNumericExpression', 'LiteralStringExpression', 'IdentifierExpression'].includes(node.right?.type) &&
|
||||
canBeOverloaded(node.left)
|
||||
) {
|
||||
let arg = node.left;
|
||||
if (node.left.type === 'IdentifierExpression') {
|
||||
arg = wrapFunction('reify', node.left);
|
||||
}
|
||||
return new CallExpression({
|
||||
callee: new StaticMemberExpression({
|
||||
property: operators[node.operator],
|
||||
object: wrapFunction('reify', arg),
|
||||
}),
|
||||
arguments: [node.right],
|
||||
});
|
||||
}
|
||||
|
||||
const isMarkable = isPatternArg(parents) || hasModifierCall(parent);
|
||||
// add to location to pure(x) calls
|
||||
if (node.type === 'CallExpression' && node.callee.name === 'pure') {
|
||||
const literal = node.arguments[0];
|
||||
// const value = literal[{ LiteralNumericExpression: 'value', LiteralStringExpression: 'name' }[literal.type]];
|
||||
return reifyWithLocation(literal, node.arguments[0], ast.locations, artificialNodes);
|
||||
}
|
||||
// replace pseudo note variables
|
||||
if (node.type === 'IdentifierExpression') {
|
||||
if (isNote(node.name)) {
|
||||
const value = node.name[1] === 's' ? node.name.replace('s', '#') : node.name;
|
||||
if (addLocations && isMarkable) {
|
||||
return reifyWithLocation(new LiteralStringExpression({ value }), node, ast.locations, artificialNodes);
|
||||
}
|
||||
return new LiteralStringExpression({ value });
|
||||
}
|
||||
if (node.name === 'r') {
|
||||
return new IdentifierExpression({ name: 'silence' });
|
||||
}
|
||||
}
|
||||
if (
|
||||
addLocations &&
|
||||
['LiteralStringExpression' /* , 'LiteralNumericExpression' */].includes(node.type) &&
|
||||
isMarkable
|
||||
) {
|
||||
// TODO: to make LiteralNumericExpression work, we need to make sure we're not inside timeCat...
|
||||
return reifyWithLocation(node, node, ast.locations, artificialNodes);
|
||||
}
|
||||
if (addMiniLocations) {
|
||||
return addMiniNotationLocations(node, ast.locations, artificialNodes);
|
||||
}
|
||||
return node;
|
||||
},
|
||||
leave() {
|
||||
parents.pop();
|
||||
},
|
||||
});
|
||||
// add return to last statement (because it's wrapped in an async function artificially)
|
||||
addReturn(shifted);
|
||||
const generated = codegen(shifted);
|
||||
return generated;
|
||||
};
|
||||
|
||||
function wrapAsync(code) {
|
||||
// wrap code in async to make await work on top level => this will create 1 line offset to locations
|
||||
// this is why line offset is -1 in getLocationObject calls below
|
||||
code = `(async () => {
|
||||
${code}
|
||||
})()`;
|
||||
const addReturn = (ast) => {
|
||||
const body = ast.statements[0].expression.callee.body; // actual code ast inside async function body
|
||||
body.statements = body.statements
|
||||
.slice(0, -1)
|
||||
.concat([new ReturnStatement({ expression: body.statements.slice(-1)[0] })]);
|
||||
};
|
||||
return {
|
||||
code,
|
||||
addReturn,
|
||||
};
|
||||
}
|
||||
|
||||
function addMiniNotationLocations(node, locations, artificialNodes) {
|
||||
const miniFunctions = ['mini', 'm'];
|
||||
// const isAlreadyWrapped = parent?.type === 'CallExpression' && parent.callee.name === 'withLocationOffset';
|
||||
if (node.type === 'CallExpression' && miniFunctions.includes(node.callee.name)) {
|
||||
// mini('c3')
|
||||
if (node.arguments.length > 1) {
|
||||
// TODO: transform mini(...args) to cat(...args.map(mini)) ?
|
||||
console.warn('multi arg mini locations not supported yet...');
|
||||
return node;
|
||||
}
|
||||
const str = node.arguments[0];
|
||||
return minifyWithLocation(str, str, locations, artificialNodes);
|
||||
}
|
||||
if (node.type === 'StaticMemberExpression' && miniFunctions.includes(node.property)) {
|
||||
// 'c3'.mini or 'c3'.m
|
||||
return minifyWithLocation(node.object, node, locations, artificialNodes);
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
function wrapFunction(name, ...args) {
|
||||
return new CallExpression({
|
||||
callee: new IdentifierExpression({ name }),
|
||||
arguments: args,
|
||||
});
|
||||
}
|
||||
|
||||
function isBackTickString(node) {
|
||||
return node.type === 'TemplateExpression' && node.elements.length === 1;
|
||||
}
|
||||
|
||||
function isStringWithDoubleQuotes(node, locations, code) {
|
||||
if (node.type !== 'LiteralStringExpression') {
|
||||
return false;
|
||||
}
|
||||
const loc = locations.get(node);
|
||||
const snippet = code.slice(loc.start.offset, loc.end.offset);
|
||||
return snippet[0] === '"'; // we can trust the end is also ", as the parsing did not fail
|
||||
}
|
||||
|
||||
// returns true if the given parents belong to a pattern argument node
|
||||
// this is used to check if a node should receive a location for highlighting
|
||||
function isPatternArg(parents) {
|
||||
if (!parents.length) {
|
||||
return false;
|
||||
}
|
||||
const ancestors = parents.slice(0, -1);
|
||||
const parent = parents[parents.length - 1];
|
||||
if (isPatternFactory(parent)) {
|
||||
return true;
|
||||
}
|
||||
if (parent?.type === 'ArrayExpression') {
|
||||
return isPatternArg(ancestors);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function hasModifierCall(parent) {
|
||||
// TODO: modifiers are more than composables, for example every is not composable but should be seen as modifier..
|
||||
// need all prototypes of Pattern
|
||||
return (
|
||||
parent?.type === 'StaticMemberExpression' && Object.keys(Pattern.prototype.composable).includes(parent.property)
|
||||
);
|
||||
}
|
||||
|
||||
function isPatternFactory(node) {
|
||||
return node?.type === 'CallExpression' && Object.keys(Pattern.prototype.factories).includes(node.callee.name);
|
||||
}
|
||||
|
||||
function canBeOverloaded(node) {
|
||||
return (node.type === 'IdentifierExpression' && isNote(node.name)) || isPatternFactory(node);
|
||||
// TODO: support sequence(c3).transpose(3).x.y.z
|
||||
}
|
||||
|
||||
// turns node in reify(value).withLocation(location), where location is the node's location in the source code
|
||||
// with this, the reified pattern can pass its location to the event, to know where to highlight when it's active
|
||||
function reifyWithLocation(literalNode, node, locations, artificialNodes) {
|
||||
const args = getLocationArguments(node, locations);
|
||||
const withLocation = new CallExpression({
|
||||
callee: new StaticMemberExpression({
|
||||
object: wrapFunction('reify', literalNode),
|
||||
property: 'withLocation',
|
||||
}),
|
||||
arguments: args,
|
||||
});
|
||||
artificialNodes.push(withLocation);
|
||||
return withLocation;
|
||||
}
|
||||
|
||||
// turns node in reify(value).withLocation(location), where location is the node's location in the source code
|
||||
// with this, the reified pattern can pass its location to the event, to know where to highlight when it's active
|
||||
function minifyWithLocation(literalNode, node, locations, artificialNodes) {
|
||||
const args = getLocationArguments(node, locations);
|
||||
const withLocation = new CallExpression({
|
||||
callee: new StaticMemberExpression({
|
||||
object: wrapFunction('mini', literalNode),
|
||||
property: 'withMiniLocation',
|
||||
}),
|
||||
arguments: args,
|
||||
});
|
||||
artificialNodes.push(withLocation);
|
||||
return withLocation;
|
||||
}
|
||||
|
||||
function getLocationArguments(node, locations) {
|
||||
const loc = locations.get(node);
|
||||
return [
|
||||
new ArrayExpression({
|
||||
elements: [
|
||||
new LiteralNumericExpression({ value: loc.start.line - 1 }), // the minus 1 assumes the code has been wrapped in async iife
|
||||
new LiteralNumericExpression({ value: loc.start.column }),
|
||||
new LiteralNumericExpression({ value: loc.start.offset }),
|
||||
],
|
||||
}),
|
||||
new ArrayExpression({
|
||||
elements: [
|
||||
new LiteralNumericExpression({ value: loc.end.line - 1 }), // the minus 1 assumes the code has been wrapped in async iife
|
||||
new LiteralNumericExpression({ value: loc.end.column }),
|
||||
new LiteralNumericExpression({ value: loc.end.offset }),
|
||||
],
|
||||
}),
|
||||
];
|
||||
}
|
||||
409
docs/dist/shift-parser/early-error-state.js
vendored
409
docs/dist/shift-parser/early-error-state.js
vendored
@ -1,409 +0,0 @@
|
||||
/**
|
||||
* Copyright 2014 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import MultiMap from '../../_snowpack/pkg/multimap.js';
|
||||
|
||||
function addEach(thisMap, ...otherMaps) {
|
||||
otherMaps.forEach(otherMap => {
|
||||
otherMap.forEachEntry((v, k) => {
|
||||
thisMap.set.apply(thisMap, [k].concat(v));
|
||||
});
|
||||
});
|
||||
return thisMap;
|
||||
}
|
||||
|
||||
let identity; // initialised below EarlyErrorState
|
||||
|
||||
export class EarlyErrorState {
|
||||
|
||||
constructor() {
|
||||
this.errors = [];
|
||||
// errors that are only errors in strict mode code
|
||||
this.strictErrors = [];
|
||||
|
||||
// Label values used in LabeledStatement nodes; cleared at function boundaries
|
||||
this.usedLabelNames = [];
|
||||
|
||||
// BreakStatement nodes; cleared at iteration; switch; and function boundaries
|
||||
this.freeBreakStatements = [];
|
||||
// ContinueStatement nodes; cleared at
|
||||
this.freeContinueStatements = [];
|
||||
|
||||
// labeled BreakStatement nodes; cleared at LabeledStatement with same Label and function boundaries
|
||||
this.freeLabeledBreakStatements = [];
|
||||
// labeled ContinueStatement nodes; cleared at labeled iteration statement with same Label and function boundaries
|
||||
this.freeLabeledContinueStatements = [];
|
||||
|
||||
// NewTargetExpression nodes; cleared at function (besides arrow expression) boundaries
|
||||
this.newTargetExpressions = [];
|
||||
|
||||
// BindingIdentifier nodes; cleared at containing declaration node
|
||||
this.boundNames = new MultiMap;
|
||||
// BindingIdentifiers that were found to be in a lexical binding position
|
||||
this.lexicallyDeclaredNames = new MultiMap;
|
||||
// BindingIdentifiers that were the name of a FunctionDeclaration
|
||||
this.functionDeclarationNames = new MultiMap;
|
||||
// BindingIdentifiers that were found to be in a variable binding position
|
||||
this.varDeclaredNames = new MultiMap;
|
||||
// BindingIdentifiers that were found to be in a variable binding position
|
||||
this.forOfVarDeclaredNames = [];
|
||||
|
||||
// Names that this module exports
|
||||
this.exportedNames = new MultiMap;
|
||||
// Locally declared names that are referenced in export declarations
|
||||
this.exportedBindings = new MultiMap;
|
||||
|
||||
// CallExpressions with Super callee
|
||||
this.superCallExpressions = [];
|
||||
// SuperCall expressions in the context of a Method named "constructor"
|
||||
this.superCallExpressionsInConstructorMethod = [];
|
||||
// MemberExpressions with Super object
|
||||
this.superPropertyExpressions = [];
|
||||
|
||||
// YieldExpression and YieldGeneratorExpression nodes; cleared at function boundaries
|
||||
this.yieldExpressions = [];
|
||||
// AwaitExpression nodes; cleared at function boundaries
|
||||
this.awaitExpressions = [];
|
||||
}
|
||||
|
||||
|
||||
addFreeBreakStatement(s) {
|
||||
this.freeBreakStatements.push(s);
|
||||
return this;
|
||||
}
|
||||
|
||||
addFreeLabeledBreakStatement(s) {
|
||||
this.freeLabeledBreakStatements.push(s);
|
||||
return this;
|
||||
}
|
||||
|
||||
clearFreeBreakStatements() {
|
||||
this.freeBreakStatements = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
addFreeContinueStatement(s) {
|
||||
this.freeContinueStatements.push(s);
|
||||
return this;
|
||||
}
|
||||
|
||||
addFreeLabeledContinueStatement(s) {
|
||||
this.freeLabeledContinueStatements.push(s);
|
||||
return this;
|
||||
}
|
||||
|
||||
clearFreeContinueStatements() {
|
||||
this.freeContinueStatements = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
enforceFreeBreakStatementErrors(createError) {
|
||||
[].push.apply(this.errors, this.freeBreakStatements.map(createError));
|
||||
this.freeBreakStatements = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
enforceFreeLabeledBreakStatementErrors(createError) {
|
||||
[].push.apply(this.errors, this.freeLabeledBreakStatements.map(createError));
|
||||
this.freeLabeledBreakStatements = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
enforceFreeContinueStatementErrors(createError) {
|
||||
[].push.apply(this.errors, this.freeContinueStatements.map(createError));
|
||||
this.freeContinueStatements = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
enforceFreeLabeledContinueStatementErrors(createError) {
|
||||
[].push.apply(this.errors, this.freeLabeledContinueStatements.map(createError));
|
||||
this.freeLabeledContinueStatements = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
observeIterationLabel(label) {
|
||||
this.usedLabelNames.push(label);
|
||||
this.freeLabeledBreakStatements = this.freeLabeledBreakStatements.filter(s => s.label !== label);
|
||||
this.freeLabeledContinueStatements = this.freeLabeledContinueStatements.filter(s => s.label !== label);
|
||||
return this;
|
||||
}
|
||||
|
||||
observeNonIterationLabel(label) {
|
||||
this.usedLabelNames.push(label);
|
||||
this.freeLabeledBreakStatements = this.freeLabeledBreakStatements.filter(s => s.label !== label);
|
||||
return this;
|
||||
}
|
||||
|
||||
clearUsedLabelNames() {
|
||||
this.usedLabelNames = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
observeSuperCallExpression(node) {
|
||||
this.superCallExpressions.push(node);
|
||||
return this;
|
||||
}
|
||||
|
||||
observeConstructorMethod() {
|
||||
this.superCallExpressionsInConstructorMethod = this.superCallExpressions;
|
||||
this.superCallExpressions = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
clearSuperCallExpressionsInConstructorMethod() {
|
||||
this.superCallExpressionsInConstructorMethod = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
enforceSuperCallExpressions(createError) {
|
||||
[].push.apply(this.errors, this.superCallExpressions.map(createError));
|
||||
[].push.apply(this.errors, this.superCallExpressionsInConstructorMethod.map(createError));
|
||||
this.superCallExpressions = [];
|
||||
this.superCallExpressionsInConstructorMethod = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
enforceSuperCallExpressionsInConstructorMethod(createError) {
|
||||
[].push.apply(this.errors, this.superCallExpressionsInConstructorMethod.map(createError));
|
||||
this.superCallExpressionsInConstructorMethod = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
observeSuperPropertyExpression(node) {
|
||||
this.superPropertyExpressions.push(node);
|
||||
return this;
|
||||
}
|
||||
|
||||
clearSuperPropertyExpressions() {
|
||||
this.superPropertyExpressions = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
enforceSuperPropertyExpressions(createError) {
|
||||
[].push.apply(this.errors, this.superPropertyExpressions.map(createError));
|
||||
this.superPropertyExpressions = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
observeNewTargetExpression(node) {
|
||||
this.newTargetExpressions.push(node);
|
||||
return this;
|
||||
}
|
||||
|
||||
clearNewTargetExpressions() {
|
||||
this.newTargetExpressions = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
bindName(name, node) {
|
||||
this.boundNames.set(name, node);
|
||||
return this;
|
||||
}
|
||||
|
||||
clearBoundNames() {
|
||||
this.boundNames = new MultiMap;
|
||||
return this;
|
||||
}
|
||||
|
||||
observeLexicalDeclaration() {
|
||||
addEach(this.lexicallyDeclaredNames, this.boundNames);
|
||||
this.boundNames = new MultiMap;
|
||||
return this;
|
||||
}
|
||||
|
||||
observeLexicalBoundary() {
|
||||
this.previousLexicallyDeclaredNames = this.lexicallyDeclaredNames;
|
||||
this.lexicallyDeclaredNames = new MultiMap;
|
||||
this.functionDeclarationNames = new MultiMap;
|
||||
return this;
|
||||
}
|
||||
|
||||
enforceDuplicateLexicallyDeclaredNames(createError) {
|
||||
this.lexicallyDeclaredNames.forEachEntry(nodes => {
|
||||
if (nodes.length > 1) {
|
||||
nodes.slice(1).forEach(dupeNode => {
|
||||
this.addError(createError(dupeNode));
|
||||
});
|
||||
}
|
||||
});
|
||||
return this;
|
||||
}
|
||||
|
||||
enforceConflictingLexicallyDeclaredNames(otherNames, createError) {
|
||||
this.lexicallyDeclaredNames.forEachEntry((nodes, bindingName) => {
|
||||
if (otherNames.has(bindingName)) {
|
||||
nodes.forEach(conflictingNode => {
|
||||
this.addError(createError(conflictingNode));
|
||||
});
|
||||
}
|
||||
});
|
||||
return this;
|
||||
}
|
||||
|
||||
observeFunctionDeclaration() {
|
||||
this.observeVarBoundary();
|
||||
addEach(this.functionDeclarationNames, this.boundNames);
|
||||
this.boundNames = new MultiMap;
|
||||
return this;
|
||||
}
|
||||
|
||||
functionDeclarationNamesAreLexical() {
|
||||
addEach(this.lexicallyDeclaredNames, this.functionDeclarationNames);
|
||||
this.functionDeclarationNames = new MultiMap;
|
||||
return this;
|
||||
}
|
||||
|
||||
observeVarDeclaration() {
|
||||
addEach(this.varDeclaredNames, this.boundNames);
|
||||
this.boundNames = new MultiMap;
|
||||
return this;
|
||||
}
|
||||
|
||||
recordForOfVars() {
|
||||
this.varDeclaredNames.forEach(bindingIdentifier => {
|
||||
this.forOfVarDeclaredNames.push(bindingIdentifier);
|
||||
});
|
||||
return this;
|
||||
}
|
||||
|
||||
observeVarBoundary() {
|
||||
this.lexicallyDeclaredNames = new MultiMap;
|
||||
this.functionDeclarationNames = new MultiMap;
|
||||
this.varDeclaredNames = new MultiMap;
|
||||
this.forOfVarDeclaredNames = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
exportName(name, node) {
|
||||
this.exportedNames.set(name, node);
|
||||
return this;
|
||||
}
|
||||
|
||||
exportDeclaredNames() {
|
||||
addEach(this.exportedNames, this.lexicallyDeclaredNames, this.varDeclaredNames);
|
||||
addEach(this.exportedBindings, this.lexicallyDeclaredNames, this.varDeclaredNames);
|
||||
return this;
|
||||
}
|
||||
|
||||
exportBinding(name, node) {
|
||||
this.exportedBindings.set(name, node);
|
||||
return this;
|
||||
}
|
||||
|
||||
clearExportedBindings() {
|
||||
this.exportedBindings = new MultiMap;
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
observeYieldExpression(node) {
|
||||
this.yieldExpressions.push(node);
|
||||
return this;
|
||||
}
|
||||
|
||||
clearYieldExpressions() {
|
||||
this.yieldExpressions = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
observeAwaitExpression(node) {
|
||||
this.awaitExpressions.push(node);
|
||||
return this;
|
||||
}
|
||||
|
||||
clearAwaitExpressions() {
|
||||
this.awaitExpressions = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
addError(e) {
|
||||
this.errors.push(e);
|
||||
return this;
|
||||
}
|
||||
|
||||
addStrictError(e) {
|
||||
this.strictErrors.push(e);
|
||||
return this;
|
||||
}
|
||||
|
||||
enforceStrictErrors() {
|
||||
[].push.apply(this.errors, this.strictErrors);
|
||||
this.strictErrors = [];
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
// MONOID IMPLEMENTATION
|
||||
|
||||
static empty() {
|
||||
return identity;
|
||||
}
|
||||
|
||||
concat(s) {
|
||||
if (this === identity) return s;
|
||||
if (s === identity) return this;
|
||||
[].push.apply(this.errors, s.errors);
|
||||
[].push.apply(this.strictErrors, s.strictErrors);
|
||||
[].push.apply(this.usedLabelNames, s.usedLabelNames);
|
||||
[].push.apply(this.freeBreakStatements, s.freeBreakStatements);
|
||||
[].push.apply(this.freeContinueStatements, s.freeContinueStatements);
|
||||
[].push.apply(this.freeLabeledBreakStatements, s.freeLabeledBreakStatements);
|
||||
[].push.apply(this.freeLabeledContinueStatements, s.freeLabeledContinueStatements);
|
||||
[].push.apply(this.newTargetExpressions, s.newTargetExpressions);
|
||||
addEach(this.boundNames, s.boundNames);
|
||||
addEach(this.lexicallyDeclaredNames, s.lexicallyDeclaredNames);
|
||||
addEach(this.functionDeclarationNames, s.functionDeclarationNames);
|
||||
addEach(this.varDeclaredNames, s.varDeclaredNames);
|
||||
[].push.apply(this.forOfVarDeclaredNames, s.forOfVarDeclaredNames);
|
||||
addEach(this.exportedNames, s.exportedNames);
|
||||
addEach(this.exportedBindings, s.exportedBindings);
|
||||
[].push.apply(this.superCallExpressions, s.superCallExpressions);
|
||||
[].push.apply(this.superCallExpressionsInConstructorMethod, s.superCallExpressionsInConstructorMethod);
|
||||
[].push.apply(this.superPropertyExpressions, s.superPropertyExpressions);
|
||||
[].push.apply(this.yieldExpressions, s.yieldExpressions);
|
||||
[].push.apply(this.awaitExpressions, s.awaitExpressions);
|
||||
return this;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
identity = new EarlyErrorState;
|
||||
Object.getOwnPropertyNames(EarlyErrorState.prototype).forEach(methodName => {
|
||||
if (methodName === 'constructor') return;
|
||||
Object.defineProperty(identity, methodName, {
|
||||
value() {
|
||||
return EarlyErrorState.prototype[methodName].apply(new EarlyErrorState, arguments);
|
||||
},
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
configurable: true,
|
||||
});
|
||||
});
|
||||
|
||||
export class EarlyError extends Error {
|
||||
constructor(node, message) {
|
||||
super(message);
|
||||
this.node = node;
|
||||
this.message = message;
|
||||
}
|
||||
}
|
||||
772
docs/dist/shift-parser/early-errors.js
vendored
772
docs/dist/shift-parser/early-errors.js
vendored
@ -1,772 +0,0 @@
|
||||
/**
|
||||
* Copyright 2014 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import reduce, { MonoidalReducer } from '../shift-reducer/index.js';
|
||||
import { isStrictModeReservedWord } from './utils.js';
|
||||
import { ErrorMessages } from './errors.js';
|
||||
|
||||
import { EarlyErrorState, EarlyError } from './early-error-state.js';
|
||||
|
||||
function isStrictFunctionBody({ directives }) {
|
||||
return directives.some(directive => directive.rawValue === 'use strict');
|
||||
}
|
||||
|
||||
function isLabelledFunction(node) {
|
||||
return node.type === 'LabeledStatement' &&
|
||||
(node.body.type === 'FunctionDeclaration' || isLabelledFunction(node.body));
|
||||
}
|
||||
|
||||
function isIterationStatement(node) {
|
||||
switch (node.type) {
|
||||
case 'LabeledStatement':
|
||||
return isIterationStatement(node.body);
|
||||
case 'DoWhileStatement':
|
||||
case 'ForInStatement':
|
||||
case 'ForOfStatement':
|
||||
case 'ForStatement':
|
||||
case 'WhileStatement':
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function isSpecialMethod(methodDefinition) {
|
||||
if (methodDefinition.name.type !== 'StaticPropertyName' || methodDefinition.name.value !== 'constructor') {
|
||||
return false;
|
||||
}
|
||||
switch (methodDefinition.type) {
|
||||
case 'Getter':
|
||||
case 'Setter':
|
||||
return true;
|
||||
case 'Method':
|
||||
return methodDefinition.isGenerator || methodDefinition.isAsync;
|
||||
}
|
||||
/* istanbul ignore next */
|
||||
throw new Error('not reached');
|
||||
}
|
||||
|
||||
|
||||
function enforceDuplicateConstructorMethods(node, s) {
|
||||
let ctors = node.elements.filter(e =>
|
||||
!e.isStatic &&
|
||||
e.method.type === 'Method' &&
|
||||
!e.method.isGenerator &&
|
||||
e.method.name.type === 'StaticPropertyName' &&
|
||||
e.method.name.value === 'constructor'
|
||||
);
|
||||
if (ctors.length > 1) {
|
||||
ctors.slice(1).forEach(ctor => {
|
||||
s = s.addError(new EarlyError(ctor, 'Duplicate constructor method in class'));
|
||||
});
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
const SUPERCALL_ERROR = node => new EarlyError(node, ErrorMessages.ILLEGAL_SUPER_CALL);
|
||||
const SUPERPROPERTY_ERROR = node => new EarlyError(node, 'Member access on super must be in a method');
|
||||
const DUPLICATE_BINDING = node => new EarlyError(node, `Duplicate binding ${JSON.stringify(node.name)}`);
|
||||
const FREE_CONTINUE = node => new EarlyError(node, 'Continue statement must be nested within an iteration statement');
|
||||
const UNBOUND_CONTINUE = node => new EarlyError(node, `Continue statement must be nested within an iteration statement with label ${JSON.stringify(node.label)}`);
|
||||
const FREE_BREAK = node => new EarlyError(node, 'Break statement must be nested within an iteration statement or a switch statement');
|
||||
const UNBOUND_BREAK = node => new EarlyError(node, `Break statement must be nested within a statement with label ${JSON.stringify(node.label)}`);
|
||||
|
||||
export class EarlyErrorChecker extends MonoidalReducer {
|
||||
constructor() {
|
||||
super(EarlyErrorState);
|
||||
}
|
||||
|
||||
reduceAssignmentExpression() {
|
||||
return super.reduceAssignmentExpression(...arguments).clearBoundNames();
|
||||
}
|
||||
|
||||
reduceAssignmentTargetIdentifier(node) {
|
||||
let s = this.identity;
|
||||
if (node.name === 'eval' || node.name === 'arguments' || isStrictModeReservedWord(node.name)) {
|
||||
s = s.addStrictError(new EarlyError(node, `The identifier ${JSON.stringify(node.name)} must not be in binding position in strict mode`));
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceArrowExpression(node, { params, body }) {
|
||||
let isSimpleParameterList = node.params.rest == null && node.params.items.every(i => i.type === 'BindingIdentifier');
|
||||
params = params.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
if (node.body.type === 'FunctionBody') {
|
||||
body = body.enforceConflictingLexicallyDeclaredNames(params.lexicallyDeclaredNames, DUPLICATE_BINDING);
|
||||
if (isStrictFunctionBody(node.body)) {
|
||||
params = params.enforceStrictErrors();
|
||||
body = body.enforceStrictErrors();
|
||||
}
|
||||
}
|
||||
params.yieldExpressions.forEach(n => {
|
||||
params = params.addError(new EarlyError(n, 'Arrow parameters must not contain yield expressions'));
|
||||
});
|
||||
params.awaitExpressions.forEach(n => {
|
||||
params = params.addError(new EarlyError(n, 'Arrow parameters must not contain await expressions'));
|
||||
});
|
||||
let s = super.reduceArrowExpression(node, { params, body });
|
||||
if (!isSimpleParameterList && node.body.type === 'FunctionBody' && isStrictFunctionBody(node.body)) {
|
||||
s = s.addError(new EarlyError(node, 'Functions with non-simple parameter lists may not contain a "use strict" directive'));
|
||||
}
|
||||
s = s.clearYieldExpressions();
|
||||
s = s.clearAwaitExpressions();
|
||||
s = s.observeVarBoundary();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceAwaitExpression(node, { expression }) {
|
||||
return expression.observeAwaitExpression(node);
|
||||
}
|
||||
|
||||
reduceBindingIdentifier(node) {
|
||||
let s = this.identity;
|
||||
if (node.name === 'eval' || node.name === 'arguments' || isStrictModeReservedWord(node.name)) {
|
||||
s = s.addStrictError(new EarlyError(node, `The identifier ${JSON.stringify(node.name)} must not be in binding position in strict mode`));
|
||||
}
|
||||
s = s.bindName(node.name, node);
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceBlock() {
|
||||
let s = super.reduceBlock(...arguments);
|
||||
s = s.functionDeclarationNamesAreLexical();
|
||||
s = s.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
s = s.enforceConflictingLexicallyDeclaredNames(s.varDeclaredNames, DUPLICATE_BINDING);
|
||||
s = s.observeLexicalBoundary();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceBreakStatement(node) {
|
||||
let s = super.reduceBreakStatement(...arguments);
|
||||
s = node.label == null
|
||||
? s.addFreeBreakStatement(node)
|
||||
: s.addFreeLabeledBreakStatement(node);
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceCallExpression(node) {
|
||||
let s = super.reduceCallExpression(...arguments);
|
||||
if (node.callee.type === 'Super') {
|
||||
s = s.observeSuperCallExpression(node);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceCatchClause(node, { binding, body }) {
|
||||
binding = binding.observeLexicalDeclaration();
|
||||
binding = binding.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
binding = binding.enforceConflictingLexicallyDeclaredNames(body.previousLexicallyDeclaredNames, DUPLICATE_BINDING);
|
||||
binding.lexicallyDeclaredNames.forEachEntry((nodes, bindingName) => {
|
||||
if (body.varDeclaredNames.has(bindingName)) {
|
||||
body.varDeclaredNames.get(bindingName).forEach(conflictingNode => {
|
||||
if (body.forOfVarDeclaredNames.indexOf(conflictingNode) >= 0) {
|
||||
binding = binding.addError(DUPLICATE_BINDING(conflictingNode));
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
let s = super.reduceCatchClause(node, { binding, body });
|
||||
s = s.observeLexicalBoundary();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceClassDeclaration(node, { name, super: _super, elements }) {
|
||||
let s = name.enforceStrictErrors();
|
||||
let sElements = this.append(...elements);
|
||||
sElements = sElements.enforceStrictErrors();
|
||||
if (node.super != null) {
|
||||
_super = _super.enforceStrictErrors();
|
||||
s = this.append(s, _super);
|
||||
sElements = sElements.clearSuperCallExpressionsInConstructorMethod();
|
||||
}
|
||||
s = this.append(s, sElements);
|
||||
s = enforceDuplicateConstructorMethods(node, s);
|
||||
s = s.observeLexicalDeclaration();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceClassElement(node) {
|
||||
let s = super.reduceClassElement(...arguments);
|
||||
if (!node.isStatic && isSpecialMethod(node.method)) {
|
||||
s = s.addError(new EarlyError(node, ErrorMessages.ILLEGAL_CONSTRUCTORS));
|
||||
}
|
||||
if (node.isStatic && node.method.name.type === 'StaticPropertyName' && node.method.name.value === 'prototype') {
|
||||
s = s.addError(new EarlyError(node, 'Static class methods cannot be named "prototype"'));
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceClassExpression(node, { name, super: _super, elements }) {
|
||||
let s = node.name == null ? this.identity : name.enforceStrictErrors();
|
||||
let sElements = this.append(...elements);
|
||||
sElements = sElements.enforceStrictErrors();
|
||||
if (node.super != null) {
|
||||
_super = _super.enforceStrictErrors();
|
||||
s = this.append(s, _super);
|
||||
sElements = sElements.clearSuperCallExpressionsInConstructorMethod();
|
||||
}
|
||||
s = this.append(s, sElements);
|
||||
s = enforceDuplicateConstructorMethods(node, s);
|
||||
s = s.clearBoundNames();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceCompoundAssignmentExpression() {
|
||||
return super.reduceCompoundAssignmentExpression(...arguments).clearBoundNames();
|
||||
}
|
||||
|
||||
reduceComputedMemberExpression(node) {
|
||||
let s = super.reduceComputedMemberExpression(...arguments);
|
||||
if (node.object.type === 'Super') {
|
||||
s = s.observeSuperPropertyExpression(node);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceContinueStatement(node) {
|
||||
let s = super.reduceContinueStatement(...arguments);
|
||||
s = node.label == null
|
||||
? s.addFreeContinueStatement(node)
|
||||
: s.addFreeLabeledContinueStatement(node);
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceDoWhileStatement(node) {
|
||||
let s = super.reduceDoWhileStatement(...arguments);
|
||||
if (isLabelledFunction(node.body)) {
|
||||
s = s.addError(new EarlyError(node.body, 'The body of a do-while statement must not be a labeled function declaration'));
|
||||
}
|
||||
s = s.clearFreeContinueStatements();
|
||||
s = s.clearFreeBreakStatements();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceExport() {
|
||||
let s = super.reduceExport(...arguments);
|
||||
s = s.functionDeclarationNamesAreLexical();
|
||||
s = s.exportDeclaredNames();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceExportFrom() {
|
||||
let s = super.reduceExportFrom(...arguments);
|
||||
s = s.clearExportedBindings();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceExportFromSpecifier(node) {
|
||||
let s = super.reduceExportFromSpecifier(...arguments);
|
||||
s = s.exportName(node.exportedName || node.name, node);
|
||||
s = s.exportBinding(node.name, node);
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceExportLocalSpecifier(node) {
|
||||
let s = super.reduceExportLocalSpecifier(...arguments);
|
||||
s = s.exportName(node.exportedName || node.name.name, node);
|
||||
s = s.exportBinding(node.name.name, node);
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceExportDefault(node) {
|
||||
let s = super.reduceExportDefault(...arguments);
|
||||
s = s.functionDeclarationNamesAreLexical();
|
||||
s = s.exportName('default', node);
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceFormalParameters() {
|
||||
let s = super.reduceFormalParameters(...arguments);
|
||||
s = s.observeLexicalDeclaration();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceForStatement(node, { init, test, update, body }) {
|
||||
if (init != null) {
|
||||
init = init.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
init = init.enforceConflictingLexicallyDeclaredNames(body.varDeclaredNames, DUPLICATE_BINDING);
|
||||
}
|
||||
let s = super.reduceForStatement(node, { init, test, update, body });
|
||||
if (node.init != null && node.init.type === 'VariableDeclaration' && node.init.kind === 'const') {
|
||||
node.init.declarators.forEach(declarator => {
|
||||
if (declarator.init == null) {
|
||||
s = s.addError(new EarlyError(declarator, 'Constant lexical declarations must have an initialiser'));
|
||||
}
|
||||
});
|
||||
}
|
||||
if (isLabelledFunction(node.body)) {
|
||||
s = s.addError(new EarlyError(node.body, 'The body of a for statement must not be a labeled function declaration'));
|
||||
}
|
||||
s = s.clearFreeContinueStatements();
|
||||
s = s.clearFreeBreakStatements();
|
||||
s = s.observeLexicalBoundary();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceForInStatement(node, { left, right, body }) {
|
||||
left = left.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
left = left.enforceConflictingLexicallyDeclaredNames(body.varDeclaredNames, DUPLICATE_BINDING);
|
||||
let s = super.reduceForInStatement(node, { left, right, body });
|
||||
if (isLabelledFunction(node.body)) {
|
||||
s = s.addError(new EarlyError(node.body, 'The body of a for-in statement must not be a labeled function declaration'));
|
||||
}
|
||||
s = s.clearFreeContinueStatements();
|
||||
s = s.clearFreeBreakStatements();
|
||||
s = s.observeLexicalBoundary();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceForOfStatement(node, { left, right, body }) {
|
||||
left = left.recordForOfVars();
|
||||
left = left.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
left = left.enforceConflictingLexicallyDeclaredNames(body.varDeclaredNames, DUPLICATE_BINDING);
|
||||
let s = super.reduceForOfStatement(node, { left, right, body });
|
||||
if (isLabelledFunction(node.body)) {
|
||||
s = s.addError(new EarlyError(node.body, 'The body of a for-of statement must not be a labeled function declaration'));
|
||||
}
|
||||
s = s.clearFreeContinueStatements();
|
||||
s = s.clearFreeBreakStatements();
|
||||
s = s.observeLexicalBoundary();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceForAwaitStatement(node, { left, right, body }) {
|
||||
left = left.recordForOfVars();
|
||||
left = left.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
left = left.enforceConflictingLexicallyDeclaredNames(body.varDeclaredNames, DUPLICATE_BINDING);
|
||||
let s = super.reduceForOfStatement(node, { left, right, body });
|
||||
if (isLabelledFunction(node.body)) {
|
||||
s = s.addError(new EarlyError(node.body, 'The body of a for-await statement must not be a labeled function declaration'));
|
||||
}
|
||||
s = s.clearFreeContinueStatements();
|
||||
s = s.clearFreeBreakStatements();
|
||||
s = s.observeLexicalBoundary();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceFunctionBody(node) {
|
||||
let s = super.reduceFunctionBody(...arguments);
|
||||
s = s.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
s = s.enforceConflictingLexicallyDeclaredNames(s.varDeclaredNames, DUPLICATE_BINDING);
|
||||
s = s.enforceFreeContinueStatementErrors(FREE_CONTINUE);
|
||||
s = s.enforceFreeLabeledContinueStatementErrors(UNBOUND_CONTINUE);
|
||||
s = s.enforceFreeBreakStatementErrors(FREE_BREAK);
|
||||
s = s.enforceFreeLabeledBreakStatementErrors(UNBOUND_BREAK);
|
||||
s = s.clearUsedLabelNames();
|
||||
s = s.clearYieldExpressions();
|
||||
s = s.clearAwaitExpressions();
|
||||
if (isStrictFunctionBody(node)) {
|
||||
s = s.enforceStrictErrors();
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceFunctionDeclaration(node, { name, params, body }) {
|
||||
let isSimpleParameterList = node.params.rest == null && node.params.items.every(i => i.type === 'BindingIdentifier');
|
||||
let addError = !isSimpleParameterList || node.isGenerator ? 'addError' : 'addStrictError';
|
||||
params.lexicallyDeclaredNames.forEachEntry(nodes => {
|
||||
if (nodes.length > 1) {
|
||||
nodes.slice(1).forEach(dupeNode => {
|
||||
params = params[addError](DUPLICATE_BINDING(dupeNode));
|
||||
});
|
||||
}
|
||||
});
|
||||
body = body.enforceConflictingLexicallyDeclaredNames(params.lexicallyDeclaredNames, DUPLICATE_BINDING);
|
||||
body = body.enforceSuperCallExpressions(SUPERCALL_ERROR);
|
||||
body = body.enforceSuperPropertyExpressions(SUPERPROPERTY_ERROR);
|
||||
params = params.enforceSuperCallExpressions(SUPERCALL_ERROR);
|
||||
params = params.enforceSuperPropertyExpressions(SUPERPROPERTY_ERROR);
|
||||
if (node.isGenerator) {
|
||||
params.yieldExpressions.forEach(n => {
|
||||
params = params.addError(new EarlyError(n, 'Generator parameters must not contain yield expressions'));
|
||||
});
|
||||
}
|
||||
if (node.isAsync) {
|
||||
params.awaitExpressions.forEach(n => {
|
||||
params = params.addError(new EarlyError(n, 'Async function parameters must not contain await expressions'));
|
||||
});
|
||||
}
|
||||
params = params.clearNewTargetExpressions();
|
||||
body = body.clearNewTargetExpressions();
|
||||
if (isStrictFunctionBody(node.body)) {
|
||||
params = params.enforceStrictErrors();
|
||||
body = body.enforceStrictErrors();
|
||||
}
|
||||
let s = super.reduceFunctionDeclaration(node, { name, params, body });
|
||||
if (!isSimpleParameterList && isStrictFunctionBody(node.body)) {
|
||||
s = s.addError(new EarlyError(node, 'Functions with non-simple parameter lists may not contain a "use strict" directive'));
|
||||
}
|
||||
s = s.clearYieldExpressions();
|
||||
s = s.clearAwaitExpressions();
|
||||
s = s.observeFunctionDeclaration();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceFunctionExpression(node, { name, params, body }) {
|
||||
let isSimpleParameterList = node.params.rest == null && node.params.items.every(i => i.type === 'BindingIdentifier');
|
||||
let addError = !isSimpleParameterList || node.isGenerator ? 'addError' : 'addStrictError';
|
||||
params.lexicallyDeclaredNames.forEachEntry((nodes, bindingName) => {
|
||||
if (nodes.length > 1) {
|
||||
nodes.slice(1).forEach(dupeNode => {
|
||||
params = params[addError](new EarlyError(dupeNode, `Duplicate binding ${JSON.stringify(bindingName)}`));
|
||||
});
|
||||
}
|
||||
});
|
||||
body = body.enforceConflictingLexicallyDeclaredNames(params.lexicallyDeclaredNames, DUPLICATE_BINDING);
|
||||
body = body.enforceSuperCallExpressions(SUPERCALL_ERROR);
|
||||
body = body.enforceSuperPropertyExpressions(SUPERPROPERTY_ERROR);
|
||||
params = params.enforceSuperCallExpressions(SUPERCALL_ERROR);
|
||||
params = params.enforceSuperPropertyExpressions(SUPERPROPERTY_ERROR);
|
||||
if (node.isGenerator) {
|
||||
params.yieldExpressions.forEach(n => {
|
||||
params = params.addError(new EarlyError(n, 'Generator parameters must not contain yield expressions'));
|
||||
});
|
||||
}
|
||||
if (node.isAsync) {
|
||||
params.awaitExpressions.forEach(n => {
|
||||
params = params.addError(new EarlyError(n, 'Async function parameters must not contain await expressions'));
|
||||
});
|
||||
}
|
||||
params = params.clearNewTargetExpressions();
|
||||
body = body.clearNewTargetExpressions();
|
||||
if (isStrictFunctionBody(node.body)) {
|
||||
params = params.enforceStrictErrors();
|
||||
body = body.enforceStrictErrors();
|
||||
}
|
||||
let s = super.reduceFunctionExpression(node, { name, params, body });
|
||||
if (!isSimpleParameterList && isStrictFunctionBody(node.body)) {
|
||||
s = s.addError(new EarlyError(node, 'Functions with non-simple parameter lists may not contain a "use strict" directive'));
|
||||
}
|
||||
s = s.clearBoundNames();
|
||||
s = s.clearYieldExpressions();
|
||||
s = s.clearAwaitExpressions();
|
||||
s = s.observeVarBoundary();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceGetter(node, { name, body }) {
|
||||
body = body.enforceSuperCallExpressions(SUPERCALL_ERROR);
|
||||
body = body.clearSuperPropertyExpressions();
|
||||
body = body.clearNewTargetExpressions();
|
||||
if (isStrictFunctionBody(node.body)) {
|
||||
body = body.enforceStrictErrors();
|
||||
}
|
||||
let s = super.reduceGetter(node, { name, body });
|
||||
s = s.observeVarBoundary();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceIdentifierExpression(node) {
|
||||
let s = this.identity;
|
||||
if (isStrictModeReservedWord(node.name)) {
|
||||
s = s.addStrictError(new EarlyError(node, `The identifier ${JSON.stringify(node.name)} must not be in expression position in strict mode`));
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceIfStatement(node, { test, consequent, alternate }) {
|
||||
if (isLabelledFunction(node.consequent)) {
|
||||
consequent = consequent.addError(new EarlyError(node.consequent, 'The consequent of an if statement must not be a labeled function declaration'));
|
||||
}
|
||||
if (node.alternate != null && isLabelledFunction(node.alternate)) {
|
||||
alternate = alternate.addError(new EarlyError(node.alternate, 'The alternate of an if statement must not be a labeled function declaration'));
|
||||
}
|
||||
if (node.consequent.type === 'FunctionDeclaration') {
|
||||
consequent = consequent.addStrictError(new EarlyError(node.consequent, 'FunctionDeclarations in IfStatements are disallowed in strict mode'));
|
||||
consequent = consequent.observeLexicalBoundary();
|
||||
}
|
||||
if (node.alternate != null && node.alternate.type === 'FunctionDeclaration') {
|
||||
alternate = alternate.addStrictError(new EarlyError(node.alternate, 'FunctionDeclarations in IfStatements are disallowed in strict mode'));
|
||||
alternate = alternate.observeLexicalBoundary();
|
||||
}
|
||||
return super.reduceIfStatement(node, { test, consequent, alternate });
|
||||
}
|
||||
|
||||
reduceImport() {
|
||||
let s = super.reduceImport(...arguments);
|
||||
s = s.observeLexicalDeclaration();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceImportNamespace() {
|
||||
let s = super.reduceImportNamespace(...arguments);
|
||||
s = s.observeLexicalDeclaration();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceLabeledStatement(node) {
|
||||
let s = super.reduceLabeledStatement(...arguments);
|
||||
if (node.label === 'yield' || isStrictModeReservedWord(node.label)) {
|
||||
s = s.addStrictError(new EarlyError(node, `The identifier ${JSON.stringify(node.label)} must not be in label position in strict mode`));
|
||||
}
|
||||
if (s.usedLabelNames.indexOf(node.label) >= 0) {
|
||||
s = s.addError(new EarlyError(node, `Label ${JSON.stringify(node.label)} has already been declared`));
|
||||
}
|
||||
if (node.body.type === 'FunctionDeclaration') {
|
||||
s = s.addStrictError(new EarlyError(node, 'Labeled FunctionDeclarations are disallowed in strict mode'));
|
||||
}
|
||||
s = isIterationStatement(node.body)
|
||||
? s.observeIterationLabel(node.label)
|
||||
: s.observeNonIterationLabel(node.label);
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceLiteralRegExpExpression() {
|
||||
let s = this.identity;
|
||||
// NOTE: the RegExp pattern acceptor is disabled until we have more confidence in its correctness (more tests)
|
||||
// if (!PatternAcceptor.test(node.pattern, node.flags.indexOf("u") >= 0)) {
|
||||
// s = s.addError(new EarlyError(node, "Invalid regular expression pattern"));
|
||||
// }
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceMethod(node, { name, params, body }) {
|
||||
let isSimpleParameterList = node.params.rest == null && node.params.items.every(i => i.type === 'BindingIdentifier');
|
||||
params = params.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
body = body.enforceConflictingLexicallyDeclaredNames(params.lexicallyDeclaredNames, DUPLICATE_BINDING);
|
||||
if (node.name.type === 'StaticPropertyName' && node.name.value === 'constructor') {
|
||||
body = body.observeConstructorMethod();
|
||||
params = params.observeConstructorMethod();
|
||||
} else {
|
||||
body = body.enforceSuperCallExpressions(SUPERCALL_ERROR);
|
||||
params = params.enforceSuperCallExpressions(SUPERCALL_ERROR);
|
||||
}
|
||||
if (node.isGenerator) {
|
||||
params.yieldExpressions.forEach(n => {
|
||||
params = params.addError(new EarlyError(n, 'Generator parameters must not contain yield expressions'));
|
||||
});
|
||||
}
|
||||
if (node.isAsync) {
|
||||
params.awaitExpressions.forEach(n => {
|
||||
params = params.addError(new EarlyError(n, 'Async function parameters must not contain await expressions'));
|
||||
});
|
||||
}
|
||||
body = body.clearSuperPropertyExpressions();
|
||||
params = params.clearSuperPropertyExpressions();
|
||||
params = params.clearNewTargetExpressions();
|
||||
body = body.clearNewTargetExpressions();
|
||||
if (isStrictFunctionBody(node.body)) {
|
||||
params = params.enforceStrictErrors();
|
||||
body = body.enforceStrictErrors();
|
||||
}
|
||||
let s = super.reduceMethod(node, { name, params, body });
|
||||
if (!isSimpleParameterList && isStrictFunctionBody(node.body)) {
|
||||
s = s.addError(new EarlyError(node, 'Functions with non-simple parameter lists may not contain a "use strict" directive'));
|
||||
}
|
||||
s = s.clearYieldExpressions();
|
||||
s = s.clearAwaitExpressions();
|
||||
s = s.observeVarBoundary();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceModule() {
|
||||
let s = super.reduceModule(...arguments);
|
||||
s = s.functionDeclarationNamesAreLexical();
|
||||
s = s.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
s = s.enforceConflictingLexicallyDeclaredNames(s.varDeclaredNames, DUPLICATE_BINDING);
|
||||
s.exportedNames.forEachEntry((nodes, bindingName) => {
|
||||
if (nodes.length > 1) {
|
||||
nodes.slice(1).forEach(dupeNode => {
|
||||
s = s.addError(new EarlyError(dupeNode, `Duplicate export ${JSON.stringify(bindingName)}`));
|
||||
});
|
||||
}
|
||||
});
|
||||
s.exportedBindings.forEachEntry((nodes, bindingName) => {
|
||||
if (!s.lexicallyDeclaredNames.has(bindingName) && !s.varDeclaredNames.has(bindingName)) {
|
||||
nodes.forEach(undeclaredNode => {
|
||||
s = s.addError(new EarlyError(undeclaredNode, `Exported binding ${JSON.stringify(bindingName)} is not declared`));
|
||||
});
|
||||
}
|
||||
});
|
||||
s.newTargetExpressions.forEach(node => {
|
||||
s = s.addError(new EarlyError(node, 'new.target must be within function (but not arrow expression) code'));
|
||||
});
|
||||
s = s.enforceFreeContinueStatementErrors(FREE_CONTINUE);
|
||||
s = s.enforceFreeLabeledContinueStatementErrors(UNBOUND_CONTINUE);
|
||||
s = s.enforceFreeBreakStatementErrors(FREE_BREAK);
|
||||
s = s.enforceFreeLabeledBreakStatementErrors(UNBOUND_BREAK);
|
||||
s = s.enforceSuperCallExpressions(SUPERCALL_ERROR);
|
||||
s = s.enforceSuperPropertyExpressions(SUPERPROPERTY_ERROR);
|
||||
s = s.enforceStrictErrors();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceNewTargetExpression(node) {
|
||||
return this.identity.observeNewTargetExpression(node);
|
||||
}
|
||||
|
||||
reduceObjectExpression(node) {
|
||||
let s = super.reduceObjectExpression(...arguments);
|
||||
s = s.enforceSuperCallExpressionsInConstructorMethod(SUPERCALL_ERROR);
|
||||
let protos = node.properties.filter(p => p.type === 'DataProperty' && p.name.type === 'StaticPropertyName' && p.name.value === '__proto__');
|
||||
protos.slice(1).forEach(n => {
|
||||
s = s.addError(new EarlyError(n, 'Duplicate __proto__ property in object literal not allowed'));
|
||||
});
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceUpdateExpression() {
|
||||
let s = super.reduceUpdateExpression(...arguments);
|
||||
s = s.clearBoundNames();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceUnaryExpression(node) {
|
||||
let s = super.reduceUnaryExpression(...arguments);
|
||||
if (node.operator === 'delete' && node.operand.type === 'IdentifierExpression') {
|
||||
s = s.addStrictError(new EarlyError(node, 'Identifier expressions must not be deleted in strict mode'));
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceScript(node) {
|
||||
let s = super.reduceScript(...arguments);
|
||||
s = s.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
s = s.enforceConflictingLexicallyDeclaredNames(s.varDeclaredNames, DUPLICATE_BINDING);
|
||||
s.newTargetExpressions.forEach(n => {
|
||||
s = s.addError(new EarlyError(n, 'new.target must be within function (but not arrow expression) code'));
|
||||
});
|
||||
s = s.enforceFreeContinueStatementErrors(FREE_CONTINUE);
|
||||
s = s.enforceFreeLabeledContinueStatementErrors(UNBOUND_CONTINUE);
|
||||
s = s.enforceFreeBreakStatementErrors(FREE_BREAK);
|
||||
s = s.enforceFreeLabeledBreakStatementErrors(UNBOUND_BREAK);
|
||||
s = s.enforceSuperCallExpressions(SUPERCALL_ERROR);
|
||||
s = s.enforceSuperPropertyExpressions(SUPERPROPERTY_ERROR);
|
||||
if (isStrictFunctionBody(node)) {
|
||||
s = s.enforceStrictErrors();
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceSetter(node, { name, param, body }) {
|
||||
let isSimpleParameterList = node.param.type === 'BindingIdentifier';
|
||||
param = param.observeLexicalDeclaration();
|
||||
param = param.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
body = body.enforceConflictingLexicallyDeclaredNames(param.lexicallyDeclaredNames, DUPLICATE_BINDING);
|
||||
param = param.enforceSuperCallExpressions(SUPERCALL_ERROR);
|
||||
body = body.enforceSuperCallExpressions(SUPERCALL_ERROR);
|
||||
param = param.clearSuperPropertyExpressions();
|
||||
body = body.clearSuperPropertyExpressions();
|
||||
param = param.clearNewTargetExpressions();
|
||||
body = body.clearNewTargetExpressions();
|
||||
if (isStrictFunctionBody(node.body)) {
|
||||
param = param.enforceStrictErrors();
|
||||
body = body.enforceStrictErrors();
|
||||
}
|
||||
let s = super.reduceSetter(node, { name, param, body });
|
||||
if (!isSimpleParameterList && isStrictFunctionBody(node.body)) {
|
||||
s = s.addError(new EarlyError(node, 'Functions with non-simple parameter lists may not contain a "use strict" directive'));
|
||||
}
|
||||
s = s.observeVarBoundary();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceStaticMemberExpression(node) {
|
||||
let s = super.reduceStaticMemberExpression(...arguments);
|
||||
if (node.object.type === 'Super') {
|
||||
s = s.observeSuperPropertyExpression(node);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceSwitchStatement(node, { discriminant, cases }) {
|
||||
let sCases = this.append(...cases);
|
||||
sCases = sCases.functionDeclarationNamesAreLexical();
|
||||
sCases = sCases.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
sCases = sCases.enforceConflictingLexicallyDeclaredNames(sCases.varDeclaredNames, DUPLICATE_BINDING);
|
||||
sCases = sCases.observeLexicalBoundary();
|
||||
let s = this.append(discriminant, sCases);
|
||||
s = s.clearFreeBreakStatements();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceSwitchStatementWithDefault(node, { discriminant, preDefaultCases, defaultCase, postDefaultCases }) {
|
||||
let sCases = this.append(defaultCase, ...preDefaultCases, ...postDefaultCases);
|
||||
sCases = sCases.functionDeclarationNamesAreLexical();
|
||||
sCases = sCases.enforceDuplicateLexicallyDeclaredNames(DUPLICATE_BINDING);
|
||||
sCases = sCases.enforceConflictingLexicallyDeclaredNames(sCases.varDeclaredNames, DUPLICATE_BINDING);
|
||||
sCases = sCases.observeLexicalBoundary();
|
||||
let s = this.append(discriminant, sCases);
|
||||
s = s.clearFreeBreakStatements();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceVariableDeclaration(node) {
|
||||
let s = super.reduceVariableDeclaration(...arguments);
|
||||
switch (node.kind) {
|
||||
case 'const':
|
||||
case 'let': {
|
||||
s = s.observeLexicalDeclaration();
|
||||
if (s.lexicallyDeclaredNames.has('let')) {
|
||||
s.lexicallyDeclaredNames.get('let').forEach(n => {
|
||||
s = s.addError(new EarlyError(n, 'Lexical declarations must not have a binding named "let"'));
|
||||
});
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'var':
|
||||
s = s.observeVarDeclaration();
|
||||
break;
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceVariableDeclarationStatement(node) {
|
||||
let s = super.reduceVariableDeclarationStatement(...arguments);
|
||||
if (node.declaration.kind === 'const') {
|
||||
node.declaration.declarators.forEach(declarator => {
|
||||
if (declarator.init == null) {
|
||||
s = s.addError(new EarlyError(declarator, 'Constant lexical declarations must have an initialiser'));
|
||||
}
|
||||
});
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceWhileStatement(node) {
|
||||
let s = super.reduceWhileStatement(...arguments);
|
||||
if (isLabelledFunction(node.body)) {
|
||||
s = s.addError(new EarlyError(node.body, 'The body of a while statement must not be a labeled function declaration'));
|
||||
}
|
||||
s = s.clearFreeContinueStatements().clearFreeBreakStatements();
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceWithStatement(node) {
|
||||
let s = super.reduceWithStatement(...arguments);
|
||||
if (isLabelledFunction(node.body)) {
|
||||
s = s.addError(new EarlyError(node.body, 'The body of a with statement must not be a labeled function declaration'));
|
||||
}
|
||||
s = s.addStrictError(new EarlyError(node, 'Strict mode code must not include a with statement'));
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceYieldExpression(node) {
|
||||
let s = super.reduceYieldExpression(...arguments);
|
||||
s = s.observeYieldExpression(node);
|
||||
return s;
|
||||
}
|
||||
|
||||
reduceYieldGeneratorExpression(node) {
|
||||
let s = super.reduceYieldGeneratorExpression(...arguments);
|
||||
s = s.observeYieldExpression(node);
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
static check(node) {
|
||||
return reduce(new EarlyErrorChecker, node).errors;
|
||||
}
|
||||
}
|
||||
119
docs/dist/shift-parser/errors.js
vendored
119
docs/dist/shift-parser/errors.js
vendored
@ -1,119 +0,0 @@
|
||||
/**
|
||||
* Copyright 2014 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
export const ErrorMessages = {
|
||||
UNEXPECTED_TOKEN(id) {
|
||||
return `Unexpected token ${JSON.stringify(id)}`;
|
||||
},
|
||||
UNEXPECTED_ILLEGAL_TOKEN(id) {
|
||||
return `Unexpected ${JSON.stringify(id)}`;
|
||||
},
|
||||
UNEXPECTED_ESCAPED_KEYWORD: 'Unexpected escaped keyword',
|
||||
UNEXPECTED_NUMBER: 'Unexpected number',
|
||||
UNEXPECTED_STRING: 'Unexpected string',
|
||||
UNEXPECTED_IDENTIFIER: 'Unexpected identifier',
|
||||
UNEXPECTED_RESERVED_WORD: 'Unexpected reserved word',
|
||||
UNEXPECTED_TEMPLATE: 'Unexpected template',
|
||||
UNEXPECTED_EOS: 'Unexpected end of input',
|
||||
UNEXPECTED_LINE_TERMINATOR: 'Unexpected line terminator',
|
||||
UNEXPECTED_COMMA_AFTER_REST: 'Unexpected comma after rest',
|
||||
UNEXPECTED_REST_PARAMETERS_INITIALIZATION: 'Rest parameter may not have a default initializer',
|
||||
NEWLINE_AFTER_THROW: 'Illegal newline after throw',
|
||||
UNTERMINATED_REGEXP: 'Invalid regular expression: missing /',
|
||||
INVALID_LAST_REST_PARAMETER: 'Rest parameter must be last formal parameter',
|
||||
INVALID_REST_PARAMETERS_INITIALIZATION: 'Rest parameter may not have a default initializer',
|
||||
INVALID_REGEXP_FLAGS: 'Invalid regular expression flags',
|
||||
INVALID_REGEX: 'Invalid regular expression',
|
||||
INVALID_LHS_IN_ASSIGNMENT: 'Invalid left-hand side in assignment',
|
||||
INVALID_LHS_IN_BINDING: 'Invalid left-hand side in binding', // todo collapse messages?
|
||||
INVALID_LHS_IN_FOR_IN: 'Invalid left-hand side in for-in',
|
||||
INVALID_LHS_IN_FOR_OF: 'Invalid left-hand side in for-of',
|
||||
INVALID_LHS_IN_FOR_AWAIT: 'Invalid left-hand side in for-await',
|
||||
INVALID_UPDATE_OPERAND: 'Increment/decrement target must be an identifier or member expression',
|
||||
INVALID_EXPONENTIATION_LHS: 'Unary expressions as the left operand of an exponentation expression ' +
|
||||
'must be disambiguated with parentheses',
|
||||
MULTIPLE_DEFAULTS_IN_SWITCH: 'More than one default clause in switch statement',
|
||||
NO_CATCH_OR_FINALLY: 'Missing catch or finally after try',
|
||||
ILLEGAL_RETURN: 'Illegal return statement',
|
||||
ILLEGAL_ARROW_FUNCTION_PARAMS: 'Illegal arrow function parameter list',
|
||||
INVALID_ASYNC_PARAMS: 'Async function parameters must not contain await expressions',
|
||||
INVALID_VAR_INIT_FOR_IN: 'Invalid variable declaration in for-in statement',
|
||||
INVALID_VAR_INIT_FOR_OF: 'Invalid variable declaration in for-of statement',
|
||||
INVALID_VAR_INIT_FOR_AWAIT: 'Invalid variable declaration in for-await statement',
|
||||
UNINITIALIZED_BINDINGPATTERN_IN_FOR_INIT: 'Binding pattern appears without initializer in for statement init',
|
||||
ILLEGAL_PROPERTY: 'Illegal property initializer',
|
||||
INVALID_ID_BINDING_STRICT_MODE(id) {
|
||||
return `The identifier ${JSON.stringify(id)} must not be in binding position in strict mode`;
|
||||
},
|
||||
INVALID_ID_IN_LABEL_STRICT_MODE(id) {
|
||||
return `The identifier ${JSON.stringify(id)} must not be in label position in strict mode`;
|
||||
},
|
||||
INVALID_ID_IN_EXPRESSION_STRICT_MODE(id) {
|
||||
return `The identifier ${JSON.stringify(id)} must not be in expression position in strict mode`;
|
||||
},
|
||||
INVALID_CALL_TO_SUPER: 'Calls to super must be in the "constructor" method of a class expression ' +
|
||||
'or class declaration that has a superclass',
|
||||
INVALID_DELETE_STRICT_MODE: 'Identifier expressions must not be deleted in strict mode',
|
||||
DUPLICATE_BINDING(id) {
|
||||
return `Duplicate binding ${JSON.stringify(id)}`;
|
||||
},
|
||||
ILLEGAL_ID_IN_LEXICAL_DECLARATION(id) {
|
||||
return `Lexical declarations must not have a binding named ${JSON.stringify(id)}`;
|
||||
},
|
||||
UNITIALIZED_CONST: 'Constant lexical declarations must have an initialiser',
|
||||
ILLEGAL_LABEL_IN_BODY(stmt) {
|
||||
return `The body of a ${stmt} statement must not be a labeled function declaration`;
|
||||
},
|
||||
ILLEGEAL_LABEL_IN_IF: 'The consequent of an if statement must not be a labeled function declaration',
|
||||
ILLEGAL_LABEL_IN_ELSE: 'The alternate of an if statement must not be a labeled function declaration',
|
||||
ILLEGAL_CONTINUE_WITHOUT_ITERATION_WITH_ID(id) {
|
||||
return `Continue statement must be nested within an iteration statement with label ${JSON.stringify(id)}`;
|
||||
},
|
||||
ILLEGAL_CONTINUE_WITHOUT_ITERATION: 'Continue statement must be nested within an iteration statement',
|
||||
ILLEGAL_BREAK_WITHOUT_ITERATION_OR_SWITCH:
|
||||
'Break statement must be nested within an iteration statement or a switch statement',
|
||||
ILLEGAL_WITH_STRICT_MODE: 'Strict mode code must not include a with statement',
|
||||
ILLEGAL_ACCESS_SUPER_MEMBER: 'Member access on super must be in a method',
|
||||
ILLEGAL_SUPER_CALL: 'Calls to super must be in the "constructor" method of a class expression or class declaration that has a superclass',
|
||||
DUPLICATE_LABEL_DECLARATION(label) {
|
||||
return `Label ${JSON.stringify(label)} has already been declared`;
|
||||
},
|
||||
ILLEGAL_BREAK_WITHIN_LABEL(label) {
|
||||
return `Break statement must be nested within a statement with label ${JSON.stringify(label)}`;
|
||||
},
|
||||
ILLEGAL_YIELD_EXPRESSIONS(paramType) {
|
||||
return `${paramType} parameters must not contain yield expressions`;
|
||||
},
|
||||
ILLEGAL_YIELD_IDENTIFIER: '"yield" may not be used as an identifier in this context',
|
||||
ILLEGAL_AWAIT_IDENTIFIER: '"await" may not be used as an identifier in this context',
|
||||
DUPLICATE_CONSTRUCTOR: 'Duplicate constructor method in class',
|
||||
ILLEGAL_CONSTRUCTORS: 'Constructors cannot be async, generators, getters or setters',
|
||||
ILLEGAL_STATIC_CLASS_NAME: 'Static class methods cannot be named "prototype"',
|
||||
NEW_TARGET_ERROR: 'new.target must be within function (but not arrow expression) code',
|
||||
DUPLICATE_EXPORT(id) {
|
||||
return `Duplicate export ${JSON.stringify(id)}`;
|
||||
},
|
||||
UNDECLARED_BINDING(id) {
|
||||
return `Exported binding ${JSON.stringify(id)} is not declared`;
|
||||
},
|
||||
DUPLICATE_PROPTO_PROP: 'Duplicate __proto__ property in object literal not allowed',
|
||||
ILLEGAL_LABEL_FUNC_DECLARATION: 'Labeled FunctionDeclarations are disallowed in strict mode',
|
||||
ILLEGAL_FUNC_DECL_IF: 'FunctionDeclarations in IfStatements are disallowed in strict mode',
|
||||
ILLEGAL_USE_STRICT: 'Functions with non-simple parameter lists may not contain a "use strict" directive',
|
||||
ILLEGAL_EXPORTED_NAME: 'Names of variables used in an export specifier from the current module must be identifiers',
|
||||
NO_OCTALS_IN_TEMPLATES: 'Template literals may not contain octal escape sequences',
|
||||
NO_AWAIT_IN_ASYNC_PARAMS: 'Async arrow parameters may not contain "await"',
|
||||
};
|
||||
149
docs/dist/shift-parser/index.js
vendored
149
docs/dist/shift-parser/index.js
vendored
@ -1,149 +0,0 @@
|
||||
/**
|
||||
* Copyright 2016 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import { GenericParser } from './parser.js';
|
||||
import { JsError } from './tokenizer.js';
|
||||
import { EarlyErrorChecker } from './early-errors.js';
|
||||
import { isLineTerminator } from './utils.js';
|
||||
|
||||
class ParserWithLocation extends GenericParser {
|
||||
constructor(source) {
|
||||
super(source);
|
||||
this.locations = new WeakMap;
|
||||
this.comments = [];
|
||||
}
|
||||
|
||||
startNode() {
|
||||
return this.getLocation();
|
||||
}
|
||||
|
||||
finishNode(node, start) {
|
||||
if (node.type === 'Script' || node.type === 'Module') {
|
||||
this.locations.set(node, {
|
||||
start: { line: 1, column: 0, offset: 0 },
|
||||
end: this.getLocation(),
|
||||
});
|
||||
return node;
|
||||
}
|
||||
if (node.type === 'TemplateExpression') {
|
||||
// Adjust TemplateElements to not include surrounding backticks or braces
|
||||
for (let i = 0; i < node.elements.length; i += 2) {
|
||||
const endAdjustment = i < node.elements.length - 1 ? 2 : 1; // discard '${' or '`' respectively
|
||||
const element = node.elements[i];
|
||||
const location = this.locations.get(element);
|
||||
this.locations.set(element, {
|
||||
start: { line: location.start.line, column: location.start.column + 1, offset: location.start.offset + 1 }, // discard '}' or '`'
|
||||
end: { line: location.end.line, column: location.end.column - endAdjustment, offset: location.end.offset - endAdjustment },
|
||||
});
|
||||
}
|
||||
}
|
||||
this.locations.set(node, {
|
||||
start,
|
||||
end: this.getLastTokenEndLocation(),
|
||||
});
|
||||
return node;
|
||||
}
|
||||
|
||||
copyNode(src, dest) {
|
||||
this.locations.set(dest, this.locations.get(src)); // todo check undefined
|
||||
return dest;
|
||||
}
|
||||
|
||||
skipSingleLineComment(offset) {
|
||||
// We're actually extending the *tokenizer*, here.
|
||||
const start = {
|
||||
line: this.line + 1,
|
||||
column: this.index - this.lineStart,
|
||||
offset: this.index,
|
||||
};
|
||||
const c = this.source[this.index];
|
||||
const type = c === '/' ? 'SingleLine' : c === '<' ? 'HTMLOpen' : 'HTMLClose';
|
||||
|
||||
super.skipSingleLineComment(offset);
|
||||
|
||||
const end = {
|
||||
line: this.line + 1,
|
||||
column: this.index - this.lineStart,
|
||||
offset: this.index,
|
||||
};
|
||||
const trailingLineTerminatorCharacters = this.source[this.index - 2] === '\r' ? 2 : isLineTerminator(this.source.charCodeAt(this.index - 1)) ? 1 : 0;
|
||||
const text = this.source.substring(start.offset + offset, end.offset - trailingLineTerminatorCharacters);
|
||||
|
||||
this.comments.push({ text, type, start, end });
|
||||
}
|
||||
|
||||
skipMultiLineComment() {
|
||||
const start = {
|
||||
line: this.line + 1,
|
||||
column: this.index - this.lineStart,
|
||||
offset: this.index,
|
||||
};
|
||||
const type = 'MultiLine';
|
||||
|
||||
const retval = super.skipMultiLineComment();
|
||||
|
||||
const end = {
|
||||
line: this.line + 1,
|
||||
column: this.index - this.lineStart,
|
||||
offset: this.index,
|
||||
};
|
||||
const text = this.source.substring(start.offset + 2, end.offset - 2);
|
||||
|
||||
this.comments.push({ text, type, start, end });
|
||||
|
||||
return retval;
|
||||
}
|
||||
}
|
||||
|
||||
function generateInterface(parsingFunctionName) {
|
||||
return function parse(code, { earlyErrors = true } = {}) {
|
||||
let parser = new GenericParser(code);
|
||||
let tree = parser[parsingFunctionName]();
|
||||
if (earlyErrors) {
|
||||
let errors = EarlyErrorChecker.check(tree);
|
||||
// for now, just throw the first error; we will handle multiple errors later
|
||||
if (errors.length > 0) {
|
||||
throw new JsError(0, 1, 0, errors[0].message);
|
||||
}
|
||||
}
|
||||
return tree;
|
||||
};
|
||||
}
|
||||
|
||||
function generateInterfaceWithLocation(parsingFunctionName) {
|
||||
return function parse(code, { earlyErrors = true } = {}) {
|
||||
let parser = new ParserWithLocation(code);
|
||||
let tree = parser[parsingFunctionName]();
|
||||
if (earlyErrors) {
|
||||
let errors = EarlyErrorChecker.check(tree);
|
||||
// for now, just throw the first error; we will handle multiple errors later
|
||||
if (errors.length > 0) {
|
||||
let { node, message } = errors[0];
|
||||
let { offset, line, column } = parser.locations.get(node).start;
|
||||
throw new JsError(offset, line, column, message);
|
||||
}
|
||||
}
|
||||
return { tree, locations: parser.locations, comments: parser.comments };
|
||||
};
|
||||
}
|
||||
|
||||
export const parseModule = generateInterface('parseModule');
|
||||
export const parseScript = generateInterface('parseScript');
|
||||
export const parseModuleWithLocation = generateInterfaceWithLocation('parseModule');
|
||||
export const parseScriptWithLocation = generateInterfaceWithLocation('parseScript');
|
||||
export default parseScript;
|
||||
export { EarlyErrorChecker, GenericParser, ParserWithLocation };
|
||||
export { default as Tokenizer, TokenClass, TokenType } from './tokenizer.js';
|
||||
2641
docs/dist/shift-parser/parser.js
vendored
2641
docs/dist/shift-parser/parser.js
vendored
File diff suppressed because it is too large
Load Diff
1505
docs/dist/shift-parser/tokenizer.js
vendored
1505
docs/dist/shift-parser/tokenizer.js
vendored
File diff suppressed because it is too large
Load Diff
11
docs/dist/shift-parser/unicode.js
vendored
11
docs/dist/shift-parser/unicode.js
vendored
File diff suppressed because one or more lines are too long
105
docs/dist/shift-parser/utils.js
vendored
105
docs/dist/shift-parser/utils.js
vendored
@ -1,105 +0,0 @@
|
||||
/**
|
||||
* Copyright 2017 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import { whitespaceArray, whitespaceBool, idStartLargeRegex, idStartBool, idContinueLargeRegex, idContinueBool } from './unicode.js';
|
||||
|
||||
|
||||
const strictReservedWords = [
|
||||
'null',
|
||||
'true',
|
||||
'false',
|
||||
|
||||
'implements',
|
||||
'interface',
|
||||
'package',
|
||||
'private',
|
||||
'protected',
|
||||
'public',
|
||||
'static',
|
||||
'let',
|
||||
|
||||
'if',
|
||||
'in',
|
||||
'do',
|
||||
'var',
|
||||
'for',
|
||||
'new',
|
||||
'try',
|
||||
'this',
|
||||
'else',
|
||||
'case',
|
||||
'void',
|
||||
'with',
|
||||
'enum',
|
||||
'while',
|
||||
'break',
|
||||
'catch',
|
||||
'throw',
|
||||
'const',
|
||||
'yield',
|
||||
'class',
|
||||
'super',
|
||||
'return',
|
||||
'typeof',
|
||||
'delete',
|
||||
'switch',
|
||||
'export',
|
||||
'import',
|
||||
'default',
|
||||
'finally',
|
||||
'extends',
|
||||
'function',
|
||||
'continue',
|
||||
'debugger',
|
||||
'instanceof',
|
||||
];
|
||||
|
||||
export function isStrictModeReservedWord(id) {
|
||||
return strictReservedWords.indexOf(id) !== -1;
|
||||
}
|
||||
|
||||
export function isWhiteSpace(ch) {
|
||||
return ch < 128 ? whitespaceBool[ch] : ch === 0xA0 || ch > 0x167F && whitespaceArray.indexOf(ch) !== -1;
|
||||
}
|
||||
|
||||
export function isLineTerminator(ch) {
|
||||
return ch === 0x0A || ch === 0x0D || ch === 0x2028 || ch === 0x2029;
|
||||
}
|
||||
|
||||
export function isIdentifierStart(ch) {
|
||||
return ch < 128 ? idStartBool[ch] : idStartLargeRegex.test(String.fromCodePoint(ch));
|
||||
}
|
||||
|
||||
export function isIdentifierPart(ch) {
|
||||
return ch < 128 ? idContinueBool[ch] : idContinueLargeRegex.test(String.fromCodePoint(ch));
|
||||
}
|
||||
|
||||
export function isDecimalDigit(ch) {
|
||||
return ch >= 48 && ch <= 57;
|
||||
}
|
||||
|
||||
export function getHexValue(rune) {
|
||||
if (rune >= '0' && rune <= '9') {
|
||||
return rune.charCodeAt(0) - 48;
|
||||
}
|
||||
if (rune >= 'a' && rune <= 'f') {
|
||||
return rune.charCodeAt(0) - 87;
|
||||
}
|
||||
if (rune >= 'A' && rune <= 'F') {
|
||||
return rune.charCodeAt(0) - 55;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
418
docs/dist/shift-reducer/adapt.js
vendored
418
docs/dist/shift-reducer/adapt.js
vendored
@ -1,418 +0,0 @@
|
||||
// Generated by generate-adapt.js
|
||||
/**
|
||||
* Copyright 2018 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import * as Shift from '../../_snowpack/pkg/shift-ast.js';
|
||||
|
||||
export default (fn, reducer) => ({
|
||||
__proto__: reducer,
|
||||
|
||||
reduceArrayAssignmentTarget(node, data) {
|
||||
return fn(super.reduceArrayAssignmentTarget(node, data), node);
|
||||
},
|
||||
|
||||
reduceArrayBinding(node, data) {
|
||||
return fn(super.reduceArrayBinding(node, data), node);
|
||||
},
|
||||
|
||||
reduceArrayExpression(node, data) {
|
||||
return fn(super.reduceArrayExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceArrowExpression(node, data) {
|
||||
return fn(super.reduceArrowExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceAssignmentExpression(node, data) {
|
||||
return fn(super.reduceAssignmentExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceAssignmentTargetIdentifier(node, data) {
|
||||
return fn(super.reduceAssignmentTargetIdentifier(node, data), node);
|
||||
},
|
||||
|
||||
reduceAssignmentTargetPropertyIdentifier(node, data) {
|
||||
return fn(super.reduceAssignmentTargetPropertyIdentifier(node, data), node);
|
||||
},
|
||||
|
||||
reduceAssignmentTargetPropertyProperty(node, data) {
|
||||
return fn(super.reduceAssignmentTargetPropertyProperty(node, data), node);
|
||||
},
|
||||
|
||||
reduceAssignmentTargetWithDefault(node, data) {
|
||||
return fn(super.reduceAssignmentTargetWithDefault(node, data), node);
|
||||
},
|
||||
|
||||
reduceAwaitExpression(node, data) {
|
||||
return fn(super.reduceAwaitExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceBinaryExpression(node, data) {
|
||||
return fn(super.reduceBinaryExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceBindingIdentifier(node, data) {
|
||||
return fn(super.reduceBindingIdentifier(node, data), node);
|
||||
},
|
||||
|
||||
reduceBindingPropertyIdentifier(node, data) {
|
||||
return fn(super.reduceBindingPropertyIdentifier(node, data), node);
|
||||
},
|
||||
|
||||
reduceBindingPropertyProperty(node, data) {
|
||||
return fn(super.reduceBindingPropertyProperty(node, data), node);
|
||||
},
|
||||
|
||||
reduceBindingWithDefault(node, data) {
|
||||
return fn(super.reduceBindingWithDefault(node, data), node);
|
||||
},
|
||||
|
||||
reduceBlock(node, data) {
|
||||
return fn(super.reduceBlock(node, data), node);
|
||||
},
|
||||
|
||||
reduceBlockStatement(node, data) {
|
||||
return fn(super.reduceBlockStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceBreakStatement(node, data) {
|
||||
return fn(super.reduceBreakStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceCallExpression(node, data) {
|
||||
return fn(super.reduceCallExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceCatchClause(node, data) {
|
||||
return fn(super.reduceCatchClause(node, data), node);
|
||||
},
|
||||
|
||||
reduceClassDeclaration(node, data) {
|
||||
return fn(super.reduceClassDeclaration(node, data), node);
|
||||
},
|
||||
|
||||
reduceClassElement(node, data) {
|
||||
return fn(super.reduceClassElement(node, data), node);
|
||||
},
|
||||
|
||||
reduceClassExpression(node, data) {
|
||||
return fn(super.reduceClassExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceCompoundAssignmentExpression(node, data) {
|
||||
return fn(super.reduceCompoundAssignmentExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceComputedMemberAssignmentTarget(node, data) {
|
||||
return fn(super.reduceComputedMemberAssignmentTarget(node, data), node);
|
||||
},
|
||||
|
||||
reduceComputedMemberExpression(node, data) {
|
||||
return fn(super.reduceComputedMemberExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceComputedPropertyName(node, data) {
|
||||
return fn(super.reduceComputedPropertyName(node, data), node);
|
||||
},
|
||||
|
||||
reduceConditionalExpression(node, data) {
|
||||
return fn(super.reduceConditionalExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceContinueStatement(node, data) {
|
||||
return fn(super.reduceContinueStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceDataProperty(node, data) {
|
||||
return fn(super.reduceDataProperty(node, data), node);
|
||||
},
|
||||
|
||||
reduceDebuggerStatement(node, data) {
|
||||
return fn(super.reduceDebuggerStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceDirective(node, data) {
|
||||
return fn(super.reduceDirective(node, data), node);
|
||||
},
|
||||
|
||||
reduceDoWhileStatement(node, data) {
|
||||
return fn(super.reduceDoWhileStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceEmptyStatement(node, data) {
|
||||
return fn(super.reduceEmptyStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceExport(node, data) {
|
||||
return fn(super.reduceExport(node, data), node);
|
||||
},
|
||||
|
||||
reduceExportAllFrom(node, data) {
|
||||
return fn(super.reduceExportAllFrom(node, data), node);
|
||||
},
|
||||
|
||||
reduceExportDefault(node, data) {
|
||||
return fn(super.reduceExportDefault(node, data), node);
|
||||
},
|
||||
|
||||
reduceExportFrom(node, data) {
|
||||
return fn(super.reduceExportFrom(node, data), node);
|
||||
},
|
||||
|
||||
reduceExportFromSpecifier(node, data) {
|
||||
return fn(super.reduceExportFromSpecifier(node, data), node);
|
||||
},
|
||||
|
||||
reduceExportLocalSpecifier(node, data) {
|
||||
return fn(super.reduceExportLocalSpecifier(node, data), node);
|
||||
},
|
||||
|
||||
reduceExportLocals(node, data) {
|
||||
return fn(super.reduceExportLocals(node, data), node);
|
||||
},
|
||||
|
||||
reduceExpressionStatement(node, data) {
|
||||
return fn(super.reduceExpressionStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceForAwaitStatement(node, data) {
|
||||
return fn(super.reduceForAwaitStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceForInStatement(node, data) {
|
||||
return fn(super.reduceForInStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceForOfStatement(node, data) {
|
||||
return fn(super.reduceForOfStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceForStatement(node, data) {
|
||||
return fn(super.reduceForStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceFormalParameters(node, data) {
|
||||
return fn(super.reduceFormalParameters(node, data), node);
|
||||
},
|
||||
|
||||
reduceFunctionBody(node, data) {
|
||||
return fn(super.reduceFunctionBody(node, data), node);
|
||||
},
|
||||
|
||||
reduceFunctionDeclaration(node, data) {
|
||||
return fn(super.reduceFunctionDeclaration(node, data), node);
|
||||
},
|
||||
|
||||
reduceFunctionExpression(node, data) {
|
||||
return fn(super.reduceFunctionExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceGetter(node, data) {
|
||||
return fn(super.reduceGetter(node, data), node);
|
||||
},
|
||||
|
||||
reduceIdentifierExpression(node, data) {
|
||||
return fn(super.reduceIdentifierExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceIfStatement(node, data) {
|
||||
return fn(super.reduceIfStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceImport(node, data) {
|
||||
return fn(super.reduceImport(node, data), node);
|
||||
},
|
||||
|
||||
reduceImportNamespace(node, data) {
|
||||
return fn(super.reduceImportNamespace(node, data), node);
|
||||
},
|
||||
|
||||
reduceImportSpecifier(node, data) {
|
||||
return fn(super.reduceImportSpecifier(node, data), node);
|
||||
},
|
||||
|
||||
reduceLabeledStatement(node, data) {
|
||||
return fn(super.reduceLabeledStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceLiteralBooleanExpression(node, data) {
|
||||
return fn(super.reduceLiteralBooleanExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceLiteralInfinityExpression(node, data) {
|
||||
return fn(super.reduceLiteralInfinityExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceLiteralNullExpression(node, data) {
|
||||
return fn(super.reduceLiteralNullExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceLiteralNumericExpression(node, data) {
|
||||
return fn(super.reduceLiteralNumericExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceLiteralRegExpExpression(node, data) {
|
||||
return fn(super.reduceLiteralRegExpExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceLiteralStringExpression(node, data) {
|
||||
return fn(super.reduceLiteralStringExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceMethod(node, data) {
|
||||
return fn(super.reduceMethod(node, data), node);
|
||||
},
|
||||
|
||||
reduceModule(node, data) {
|
||||
return fn(super.reduceModule(node, data), node);
|
||||
},
|
||||
|
||||
reduceNewExpression(node, data) {
|
||||
return fn(super.reduceNewExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceNewTargetExpression(node, data) {
|
||||
return fn(super.reduceNewTargetExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceObjectAssignmentTarget(node, data) {
|
||||
return fn(super.reduceObjectAssignmentTarget(node, data), node);
|
||||
},
|
||||
|
||||
reduceObjectBinding(node, data) {
|
||||
return fn(super.reduceObjectBinding(node, data), node);
|
||||
},
|
||||
|
||||
reduceObjectExpression(node, data) {
|
||||
return fn(super.reduceObjectExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceReturnStatement(node, data) {
|
||||
return fn(super.reduceReturnStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceScript(node, data) {
|
||||
return fn(super.reduceScript(node, data), node);
|
||||
},
|
||||
|
||||
reduceSetter(node, data) {
|
||||
return fn(super.reduceSetter(node, data), node);
|
||||
},
|
||||
|
||||
reduceShorthandProperty(node, data) {
|
||||
return fn(super.reduceShorthandProperty(node, data), node);
|
||||
},
|
||||
|
||||
reduceSpreadElement(node, data) {
|
||||
return fn(super.reduceSpreadElement(node, data), node);
|
||||
},
|
||||
|
||||
reduceSpreadProperty(node, data) {
|
||||
return fn(super.reduceSpreadProperty(node, data), node);
|
||||
},
|
||||
|
||||
reduceStaticMemberAssignmentTarget(node, data) {
|
||||
return fn(super.reduceStaticMemberAssignmentTarget(node, data), node);
|
||||
},
|
||||
|
||||
reduceStaticMemberExpression(node, data) {
|
||||
return fn(super.reduceStaticMemberExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceStaticPropertyName(node, data) {
|
||||
return fn(super.reduceStaticPropertyName(node, data), node);
|
||||
},
|
||||
|
||||
reduceSuper(node, data) {
|
||||
return fn(super.reduceSuper(node, data), node);
|
||||
},
|
||||
|
||||
reduceSwitchCase(node, data) {
|
||||
return fn(super.reduceSwitchCase(node, data), node);
|
||||
},
|
||||
|
||||
reduceSwitchDefault(node, data) {
|
||||
return fn(super.reduceSwitchDefault(node, data), node);
|
||||
},
|
||||
|
||||
reduceSwitchStatement(node, data) {
|
||||
return fn(super.reduceSwitchStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceSwitchStatementWithDefault(node, data) {
|
||||
return fn(super.reduceSwitchStatementWithDefault(node, data), node);
|
||||
},
|
||||
|
||||
reduceTemplateElement(node, data) {
|
||||
return fn(super.reduceTemplateElement(node, data), node);
|
||||
},
|
||||
|
||||
reduceTemplateExpression(node, data) {
|
||||
return fn(super.reduceTemplateExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceThisExpression(node, data) {
|
||||
return fn(super.reduceThisExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceThrowStatement(node, data) {
|
||||
return fn(super.reduceThrowStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceTryCatchStatement(node, data) {
|
||||
return fn(super.reduceTryCatchStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceTryFinallyStatement(node, data) {
|
||||
return fn(super.reduceTryFinallyStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceUnaryExpression(node, data) {
|
||||
return fn(super.reduceUnaryExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceUpdateExpression(node, data) {
|
||||
return fn(super.reduceUpdateExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceVariableDeclaration(node, data) {
|
||||
return fn(super.reduceVariableDeclaration(node, data), node);
|
||||
},
|
||||
|
||||
reduceVariableDeclarationStatement(node, data) {
|
||||
return fn(super.reduceVariableDeclarationStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceVariableDeclarator(node, data) {
|
||||
return fn(super.reduceVariableDeclarator(node, data), node);
|
||||
},
|
||||
|
||||
reduceWhileStatement(node, data) {
|
||||
return fn(super.reduceWhileStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceWithStatement(node, data) {
|
||||
return fn(super.reduceWithStatement(node, data), node);
|
||||
},
|
||||
|
||||
reduceYieldExpression(node, data) {
|
||||
return fn(super.reduceYieldExpression(node, data), node);
|
||||
},
|
||||
|
||||
reduceYieldGeneratorExpression(node, data) {
|
||||
return fn(super.reduceYieldGeneratorExpression(node, data), node);
|
||||
},
|
||||
});
|
||||
416
docs/dist/shift-reducer/clone-reducer.js
vendored
416
docs/dist/shift-reducer/clone-reducer.js
vendored
@ -1,416 +0,0 @@
|
||||
// Generated by generate-clone-reducer.js
|
||||
/**
|
||||
* Copyright 2018 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import * as Shift from '../../_snowpack/pkg/shift-ast.js';
|
||||
|
||||
export default class CloneReducer {
|
||||
reduceArrayAssignmentTarget(node, { elements, rest }) {
|
||||
return new Shift.ArrayAssignmentTarget({ elements, rest });
|
||||
}
|
||||
|
||||
reduceArrayBinding(node, { elements, rest }) {
|
||||
return new Shift.ArrayBinding({ elements, rest });
|
||||
}
|
||||
|
||||
reduceArrayExpression(node, { elements }) {
|
||||
return new Shift.ArrayExpression({ elements });
|
||||
}
|
||||
|
||||
reduceArrowExpression(node, { params, body }) {
|
||||
return new Shift.ArrowExpression({ isAsync: node.isAsync, params, body });
|
||||
}
|
||||
|
||||
reduceAssignmentExpression(node, { binding, expression }) {
|
||||
return new Shift.AssignmentExpression({ binding, expression });
|
||||
}
|
||||
|
||||
reduceAssignmentTargetIdentifier(node) {
|
||||
return new Shift.AssignmentTargetIdentifier({ name: node.name });
|
||||
}
|
||||
|
||||
reduceAssignmentTargetPropertyIdentifier(node, { binding, init }) {
|
||||
return new Shift.AssignmentTargetPropertyIdentifier({ binding, init });
|
||||
}
|
||||
|
||||
reduceAssignmentTargetPropertyProperty(node, { name, binding }) {
|
||||
return new Shift.AssignmentTargetPropertyProperty({ name, binding });
|
||||
}
|
||||
|
||||
reduceAssignmentTargetWithDefault(node, { binding, init }) {
|
||||
return new Shift.AssignmentTargetWithDefault({ binding, init });
|
||||
}
|
||||
|
||||
reduceAwaitExpression(node, { expression }) {
|
||||
return new Shift.AwaitExpression({ expression });
|
||||
}
|
||||
|
||||
reduceBinaryExpression(node, { left, right }) {
|
||||
return new Shift.BinaryExpression({ left, operator: node.operator, right });
|
||||
}
|
||||
|
||||
reduceBindingIdentifier(node) {
|
||||
return new Shift.BindingIdentifier({ name: node.name });
|
||||
}
|
||||
|
||||
reduceBindingPropertyIdentifier(node, { binding, init }) {
|
||||
return new Shift.BindingPropertyIdentifier({ binding, init });
|
||||
}
|
||||
|
||||
reduceBindingPropertyProperty(node, { name, binding }) {
|
||||
return new Shift.BindingPropertyProperty({ name, binding });
|
||||
}
|
||||
|
||||
reduceBindingWithDefault(node, { binding, init }) {
|
||||
return new Shift.BindingWithDefault({ binding, init });
|
||||
}
|
||||
|
||||
reduceBlock(node, { statements }) {
|
||||
return new Shift.Block({ statements });
|
||||
}
|
||||
|
||||
reduceBlockStatement(node, { block }) {
|
||||
return new Shift.BlockStatement({ block });
|
||||
}
|
||||
|
||||
reduceBreakStatement(node) {
|
||||
return new Shift.BreakStatement({ label: node.label });
|
||||
}
|
||||
|
||||
reduceCallExpression(node, { callee, arguments: _arguments }) {
|
||||
return new Shift.CallExpression({ callee, arguments: _arguments });
|
||||
}
|
||||
|
||||
reduceCatchClause(node, { binding, body }) {
|
||||
return new Shift.CatchClause({ binding, body });
|
||||
}
|
||||
|
||||
reduceClassDeclaration(node, { name, super: _super, elements }) {
|
||||
return new Shift.ClassDeclaration({ name, super: _super, elements });
|
||||
}
|
||||
|
||||
reduceClassElement(node, { method }) {
|
||||
return new Shift.ClassElement({ isStatic: node.isStatic, method });
|
||||
}
|
||||
|
||||
reduceClassExpression(node, { name, super: _super, elements }) {
|
||||
return new Shift.ClassExpression({ name, super: _super, elements });
|
||||
}
|
||||
|
||||
reduceCompoundAssignmentExpression(node, { binding, expression }) {
|
||||
return new Shift.CompoundAssignmentExpression({ binding, operator: node.operator, expression });
|
||||
}
|
||||
|
||||
reduceComputedMemberAssignmentTarget(node, { object, expression }) {
|
||||
return new Shift.ComputedMemberAssignmentTarget({ object, expression });
|
||||
}
|
||||
|
||||
reduceComputedMemberExpression(node, { object, expression }) {
|
||||
return new Shift.ComputedMemberExpression({ object, expression });
|
||||
}
|
||||
|
||||
reduceComputedPropertyName(node, { expression }) {
|
||||
return new Shift.ComputedPropertyName({ expression });
|
||||
}
|
||||
|
||||
reduceConditionalExpression(node, { test, consequent, alternate }) {
|
||||
return new Shift.ConditionalExpression({ test, consequent, alternate });
|
||||
}
|
||||
|
||||
reduceContinueStatement(node) {
|
||||
return new Shift.ContinueStatement({ label: node.label });
|
||||
}
|
||||
|
||||
reduceDataProperty(node, { name, expression }) {
|
||||
return new Shift.DataProperty({ name, expression });
|
||||
}
|
||||
|
||||
reduceDebuggerStatement(node) {
|
||||
return new Shift.DebuggerStatement;
|
||||
}
|
||||
|
||||
reduceDirective(node) {
|
||||
return new Shift.Directive({ rawValue: node.rawValue });
|
||||
}
|
||||
|
||||
reduceDoWhileStatement(node, { body, test }) {
|
||||
return new Shift.DoWhileStatement({ body, test });
|
||||
}
|
||||
|
||||
reduceEmptyStatement(node) {
|
||||
return new Shift.EmptyStatement;
|
||||
}
|
||||
|
||||
reduceExport(node, { declaration }) {
|
||||
return new Shift.Export({ declaration });
|
||||
}
|
||||
|
||||
reduceExportAllFrom(node) {
|
||||
return new Shift.ExportAllFrom({ moduleSpecifier: node.moduleSpecifier });
|
||||
}
|
||||
|
||||
reduceExportDefault(node, { body }) {
|
||||
return new Shift.ExportDefault({ body });
|
||||
}
|
||||
|
||||
reduceExportFrom(node, { namedExports }) {
|
||||
return new Shift.ExportFrom({ namedExports, moduleSpecifier: node.moduleSpecifier });
|
||||
}
|
||||
|
||||
reduceExportFromSpecifier(node) {
|
||||
return new Shift.ExportFromSpecifier({ name: node.name, exportedName: node.exportedName });
|
||||
}
|
||||
|
||||
reduceExportLocalSpecifier(node, { name }) {
|
||||
return new Shift.ExportLocalSpecifier({ name, exportedName: node.exportedName });
|
||||
}
|
||||
|
||||
reduceExportLocals(node, { namedExports }) {
|
||||
return new Shift.ExportLocals({ namedExports });
|
||||
}
|
||||
|
||||
reduceExpressionStatement(node, { expression }) {
|
||||
return new Shift.ExpressionStatement({ expression });
|
||||
}
|
||||
|
||||
reduceForAwaitStatement(node, { left, right, body }) {
|
||||
return new Shift.ForAwaitStatement({ left, right, body });
|
||||
}
|
||||
|
||||
reduceForInStatement(node, { left, right, body }) {
|
||||
return new Shift.ForInStatement({ left, right, body });
|
||||
}
|
||||
|
||||
reduceForOfStatement(node, { left, right, body }) {
|
||||
return new Shift.ForOfStatement({ left, right, body });
|
||||
}
|
||||
|
||||
reduceForStatement(node, { init, test, update, body }) {
|
||||
return new Shift.ForStatement({ init, test, update, body });
|
||||
}
|
||||
|
||||
reduceFormalParameters(node, { items, rest }) {
|
||||
return new Shift.FormalParameters({ items, rest });
|
||||
}
|
||||
|
||||
reduceFunctionBody(node, { directives, statements }) {
|
||||
return new Shift.FunctionBody({ directives, statements });
|
||||
}
|
||||
|
||||
reduceFunctionDeclaration(node, { name, params, body }) {
|
||||
return new Shift.FunctionDeclaration({ isAsync: node.isAsync, isGenerator: node.isGenerator, name, params, body });
|
||||
}
|
||||
|
||||
reduceFunctionExpression(node, { name, params, body }) {
|
||||
return new Shift.FunctionExpression({ isAsync: node.isAsync, isGenerator: node.isGenerator, name, params, body });
|
||||
}
|
||||
|
||||
reduceGetter(node, { name, body }) {
|
||||
return new Shift.Getter({ name, body });
|
||||
}
|
||||
|
||||
reduceIdentifierExpression(node) {
|
||||
return new Shift.IdentifierExpression({ name: node.name });
|
||||
}
|
||||
|
||||
reduceIfStatement(node, { test, consequent, alternate }) {
|
||||
return new Shift.IfStatement({ test, consequent, alternate });
|
||||
}
|
||||
|
||||
reduceImport(node, { defaultBinding, namedImports }) {
|
||||
return new Shift.Import({ defaultBinding, namedImports, moduleSpecifier: node.moduleSpecifier });
|
||||
}
|
||||
|
||||
reduceImportNamespace(node, { defaultBinding, namespaceBinding }) {
|
||||
return new Shift.ImportNamespace({ defaultBinding, namespaceBinding, moduleSpecifier: node.moduleSpecifier });
|
||||
}
|
||||
|
||||
reduceImportSpecifier(node, { binding }) {
|
||||
return new Shift.ImportSpecifier({ name: node.name, binding });
|
||||
}
|
||||
|
||||
reduceLabeledStatement(node, { body }) {
|
||||
return new Shift.LabeledStatement({ label: node.label, body });
|
||||
}
|
||||
|
||||
reduceLiteralBooleanExpression(node) {
|
||||
return new Shift.LiteralBooleanExpression({ value: node.value });
|
||||
}
|
||||
|
||||
reduceLiteralInfinityExpression(node) {
|
||||
return new Shift.LiteralInfinityExpression;
|
||||
}
|
||||
|
||||
reduceLiteralNullExpression(node) {
|
||||
return new Shift.LiteralNullExpression;
|
||||
}
|
||||
|
||||
reduceLiteralNumericExpression(node) {
|
||||
return new Shift.LiteralNumericExpression({ value: node.value });
|
||||
}
|
||||
|
||||
reduceLiteralRegExpExpression(node) {
|
||||
return new Shift.LiteralRegExpExpression({ pattern: node.pattern, global: node.global, ignoreCase: node.ignoreCase, multiLine: node.multiLine, dotAll: node.dotAll, unicode: node.unicode, sticky: node.sticky });
|
||||
}
|
||||
|
||||
reduceLiteralStringExpression(node) {
|
||||
return new Shift.LiteralStringExpression({ value: node.value });
|
||||
}
|
||||
|
||||
reduceMethod(node, { name, params, body }) {
|
||||
return new Shift.Method({ isAsync: node.isAsync, isGenerator: node.isGenerator, name, params, body });
|
||||
}
|
||||
|
||||
reduceModule(node, { directives, items }) {
|
||||
return new Shift.Module({ directives, items });
|
||||
}
|
||||
|
||||
reduceNewExpression(node, { callee, arguments: _arguments }) {
|
||||
return new Shift.NewExpression({ callee, arguments: _arguments });
|
||||
}
|
||||
|
||||
reduceNewTargetExpression(node) {
|
||||
return new Shift.NewTargetExpression;
|
||||
}
|
||||
|
||||
reduceObjectAssignmentTarget(node, { properties, rest }) {
|
||||
return new Shift.ObjectAssignmentTarget({ properties, rest });
|
||||
}
|
||||
|
||||
reduceObjectBinding(node, { properties, rest }) {
|
||||
return new Shift.ObjectBinding({ properties, rest });
|
||||
}
|
||||
|
||||
reduceObjectExpression(node, { properties }) {
|
||||
return new Shift.ObjectExpression({ properties });
|
||||
}
|
||||
|
||||
reduceReturnStatement(node, { expression }) {
|
||||
return new Shift.ReturnStatement({ expression });
|
||||
}
|
||||
|
||||
reduceScript(node, { directives, statements }) {
|
||||
return new Shift.Script({ directives, statements });
|
||||
}
|
||||
|
||||
reduceSetter(node, { name, param, body }) {
|
||||
return new Shift.Setter({ name, param, body });
|
||||
}
|
||||
|
||||
reduceShorthandProperty(node, { name }) {
|
||||
return new Shift.ShorthandProperty({ name });
|
||||
}
|
||||
|
||||
reduceSpreadElement(node, { expression }) {
|
||||
return new Shift.SpreadElement({ expression });
|
||||
}
|
||||
|
||||
reduceSpreadProperty(node, { expression }) {
|
||||
return new Shift.SpreadProperty({ expression });
|
||||
}
|
||||
|
||||
reduceStaticMemberAssignmentTarget(node, { object }) {
|
||||
return new Shift.StaticMemberAssignmentTarget({ object, property: node.property });
|
||||
}
|
||||
|
||||
reduceStaticMemberExpression(node, { object }) {
|
||||
return new Shift.StaticMemberExpression({ object, property: node.property });
|
||||
}
|
||||
|
||||
reduceStaticPropertyName(node) {
|
||||
return new Shift.StaticPropertyName({ value: node.value });
|
||||
}
|
||||
|
||||
reduceSuper(node) {
|
||||
return new Shift.Super;
|
||||
}
|
||||
|
||||
reduceSwitchCase(node, { test, consequent }) {
|
||||
return new Shift.SwitchCase({ test, consequent });
|
||||
}
|
||||
|
||||
reduceSwitchDefault(node, { consequent }) {
|
||||
return new Shift.SwitchDefault({ consequent });
|
||||
}
|
||||
|
||||
reduceSwitchStatement(node, { discriminant, cases }) {
|
||||
return new Shift.SwitchStatement({ discriminant, cases });
|
||||
}
|
||||
|
||||
reduceSwitchStatementWithDefault(node, { discriminant, preDefaultCases, defaultCase, postDefaultCases }) {
|
||||
return new Shift.SwitchStatementWithDefault({ discriminant, preDefaultCases, defaultCase, postDefaultCases });
|
||||
}
|
||||
|
||||
reduceTemplateElement(node) {
|
||||
return new Shift.TemplateElement({ rawValue: node.rawValue });
|
||||
}
|
||||
|
||||
reduceTemplateExpression(node, { tag, elements }) {
|
||||
return new Shift.TemplateExpression({ tag, elements });
|
||||
}
|
||||
|
||||
reduceThisExpression(node) {
|
||||
return new Shift.ThisExpression;
|
||||
}
|
||||
|
||||
reduceThrowStatement(node, { expression }) {
|
||||
return new Shift.ThrowStatement({ expression });
|
||||
}
|
||||
|
||||
reduceTryCatchStatement(node, { body, catchClause }) {
|
||||
return new Shift.TryCatchStatement({ body, catchClause });
|
||||
}
|
||||
|
||||
reduceTryFinallyStatement(node, { body, catchClause, finalizer }) {
|
||||
return new Shift.TryFinallyStatement({ body, catchClause, finalizer });
|
||||
}
|
||||
|
||||
reduceUnaryExpression(node, { operand }) {
|
||||
return new Shift.UnaryExpression({ operator: node.operator, operand });
|
||||
}
|
||||
|
||||
reduceUpdateExpression(node, { operand }) {
|
||||
return new Shift.UpdateExpression({ isPrefix: node.isPrefix, operator: node.operator, operand });
|
||||
}
|
||||
|
||||
reduceVariableDeclaration(node, { declarators }) {
|
||||
return new Shift.VariableDeclaration({ kind: node.kind, declarators });
|
||||
}
|
||||
|
||||
reduceVariableDeclarationStatement(node, { declaration }) {
|
||||
return new Shift.VariableDeclarationStatement({ declaration });
|
||||
}
|
||||
|
||||
reduceVariableDeclarator(node, { binding, init }) {
|
||||
return new Shift.VariableDeclarator({ binding, init });
|
||||
}
|
||||
|
||||
reduceWhileStatement(node, { test, body }) {
|
||||
return new Shift.WhileStatement({ test, body });
|
||||
}
|
||||
|
||||
reduceWithStatement(node, { object, body }) {
|
||||
return new Shift.WithStatement({ object, body });
|
||||
}
|
||||
|
||||
reduceYieldExpression(node, { expression }) {
|
||||
return new Shift.YieldExpression({ expression });
|
||||
}
|
||||
|
||||
reduceYieldGeneratorExpression(node, { expression }) {
|
||||
return new Shift.YieldGeneratorExpression({ expression });
|
||||
}
|
||||
}
|
||||
418
docs/dist/shift-reducer/director.js
vendored
418
docs/dist/shift-reducer/director.js
vendored
@ -1,418 +0,0 @@
|
||||
// Generated by generate-director.js
|
||||
/**
|
||||
* Copyright 2018 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
const director = {
|
||||
ArrayAssignmentTarget(reducer, node) {
|
||||
return reducer.reduceArrayAssignmentTarget(node, { elements: node.elements.map(v => v && this[v.type](reducer, v)), rest: node.rest && this[node.rest.type](reducer, node.rest) });
|
||||
},
|
||||
|
||||
ArrayBinding(reducer, node) {
|
||||
return reducer.reduceArrayBinding(node, { elements: node.elements.map(v => v && this[v.type](reducer, v)), rest: node.rest && this[node.rest.type](reducer, node.rest) });
|
||||
},
|
||||
|
||||
ArrayExpression(reducer, node) {
|
||||
return reducer.reduceArrayExpression(node, { elements: node.elements.map(v => v && this[v.type](reducer, v)) });
|
||||
},
|
||||
|
||||
ArrowExpression(reducer, node) {
|
||||
return reducer.reduceArrowExpression(node, { params: this.FormalParameters(reducer, node.params), body: this[node.body.type](reducer, node.body) });
|
||||
},
|
||||
|
||||
AssignmentExpression(reducer, node) {
|
||||
return reducer.reduceAssignmentExpression(node, { binding: this[node.binding.type](reducer, node.binding), expression: this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
|
||||
AssignmentTargetIdentifier(reducer, node) {
|
||||
return reducer.reduceAssignmentTargetIdentifier(node);
|
||||
},
|
||||
|
||||
AssignmentTargetPropertyIdentifier(reducer, node) {
|
||||
return reducer.reduceAssignmentTargetPropertyIdentifier(node, { binding: this.AssignmentTargetIdentifier(reducer, node.binding), init: node.init && this[node.init.type](reducer, node.init) });
|
||||
},
|
||||
|
||||
AssignmentTargetPropertyProperty(reducer, node) {
|
||||
return reducer.reduceAssignmentTargetPropertyProperty(node, { name: this[node.name.type](reducer, node.name), binding: this[node.binding.type](reducer, node.binding) });
|
||||
},
|
||||
|
||||
AssignmentTargetWithDefault(reducer, node) {
|
||||
return reducer.reduceAssignmentTargetWithDefault(node, { binding: this[node.binding.type](reducer, node.binding), init: this[node.init.type](reducer, node.init) });
|
||||
},
|
||||
|
||||
AwaitExpression(reducer, node) {
|
||||
return reducer.reduceAwaitExpression(node, { expression: this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
|
||||
BinaryExpression(reducer, node) {
|
||||
return reducer.reduceBinaryExpression(node, { left: this[node.left.type](reducer, node.left), right: this[node.right.type](reducer, node.right) });
|
||||
},
|
||||
|
||||
BindingIdentifier(reducer, node) {
|
||||
return reducer.reduceBindingIdentifier(node);
|
||||
},
|
||||
|
||||
BindingPropertyIdentifier(reducer, node) {
|
||||
return reducer.reduceBindingPropertyIdentifier(node, { binding: this.BindingIdentifier(reducer, node.binding), init: node.init && this[node.init.type](reducer, node.init) });
|
||||
},
|
||||
|
||||
BindingPropertyProperty(reducer, node) {
|
||||
return reducer.reduceBindingPropertyProperty(node, { name: this[node.name.type](reducer, node.name), binding: this[node.binding.type](reducer, node.binding) });
|
||||
},
|
||||
|
||||
BindingWithDefault(reducer, node) {
|
||||
return reducer.reduceBindingWithDefault(node, { binding: this[node.binding.type](reducer, node.binding), init: this[node.init.type](reducer, node.init) });
|
||||
},
|
||||
|
||||
Block(reducer, node) {
|
||||
return reducer.reduceBlock(node, { statements: node.statements.map(v => this[v.type](reducer, v)) });
|
||||
},
|
||||
|
||||
BlockStatement(reducer, node) {
|
||||
return reducer.reduceBlockStatement(node, { block: this.Block(reducer, node.block) });
|
||||
},
|
||||
|
||||
BreakStatement(reducer, node) {
|
||||
return reducer.reduceBreakStatement(node);
|
||||
},
|
||||
|
||||
CallExpression(reducer, node) {
|
||||
return reducer.reduceCallExpression(node, { callee: this[node.callee.type](reducer, node.callee), arguments: node.arguments.map(v => this[v.type](reducer, v)) });
|
||||
},
|
||||
|
||||
CatchClause(reducer, node) {
|
||||
return reducer.reduceCatchClause(node, { binding: this[node.binding.type](reducer, node.binding), body: this.Block(reducer, node.body) });
|
||||
},
|
||||
|
||||
ClassDeclaration(reducer, node) {
|
||||
return reducer.reduceClassDeclaration(node, { name: this.BindingIdentifier(reducer, node.name), super: node.super && this[node.super.type](reducer, node.super), elements: node.elements.map(v => this.ClassElement(reducer, v)) });
|
||||
},
|
||||
|
||||
ClassElement(reducer, node) {
|
||||
return reducer.reduceClassElement(node, { method: this[node.method.type](reducer, node.method) });
|
||||
},
|
||||
|
||||
ClassExpression(reducer, node) {
|
||||
return reducer.reduceClassExpression(node, { name: node.name && this.BindingIdentifier(reducer, node.name), super: node.super && this[node.super.type](reducer, node.super), elements: node.elements.map(v => this.ClassElement(reducer, v)) });
|
||||
},
|
||||
|
||||
CompoundAssignmentExpression(reducer, node) {
|
||||
return reducer.reduceCompoundAssignmentExpression(node, { binding: this[node.binding.type](reducer, node.binding), expression: this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
|
||||
ComputedMemberAssignmentTarget(reducer, node) {
|
||||
return reducer.reduceComputedMemberAssignmentTarget(node, { object: this[node.object.type](reducer, node.object), expression: this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
|
||||
ComputedMemberExpression(reducer, node) {
|
||||
return reducer.reduceComputedMemberExpression(node, { object: this[node.object.type](reducer, node.object), expression: this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
|
||||
ComputedPropertyName(reducer, node) {
|
||||
return reducer.reduceComputedPropertyName(node, { expression: this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
|
||||
ConditionalExpression(reducer, node) {
|
||||
return reducer.reduceConditionalExpression(node, { test: this[node.test.type](reducer, node.test), consequent: this[node.consequent.type](reducer, node.consequent), alternate: this[node.alternate.type](reducer, node.alternate) });
|
||||
},
|
||||
|
||||
ContinueStatement(reducer, node) {
|
||||
return reducer.reduceContinueStatement(node);
|
||||
},
|
||||
|
||||
DataProperty(reducer, node) {
|
||||
return reducer.reduceDataProperty(node, { name: this[node.name.type](reducer, node.name), expression: this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
|
||||
DebuggerStatement(reducer, node) {
|
||||
return reducer.reduceDebuggerStatement(node);
|
||||
},
|
||||
|
||||
Directive(reducer, node) {
|
||||
return reducer.reduceDirective(node);
|
||||
},
|
||||
|
||||
DoWhileStatement(reducer, node) {
|
||||
return reducer.reduceDoWhileStatement(node, { body: this[node.body.type](reducer, node.body), test: this[node.test.type](reducer, node.test) });
|
||||
},
|
||||
|
||||
EmptyStatement(reducer, node) {
|
||||
return reducer.reduceEmptyStatement(node);
|
||||
},
|
||||
|
||||
Export(reducer, node) {
|
||||
return reducer.reduceExport(node, { declaration: this[node.declaration.type](reducer, node.declaration) });
|
||||
},
|
||||
|
||||
ExportAllFrom(reducer, node) {
|
||||
return reducer.reduceExportAllFrom(node);
|
||||
},
|
||||
|
||||
ExportDefault(reducer, node) {
|
||||
return reducer.reduceExportDefault(node, { body: this[node.body.type](reducer, node.body) });
|
||||
},
|
||||
|
||||
ExportFrom(reducer, node) {
|
||||
return reducer.reduceExportFrom(node, { namedExports: node.namedExports.map(v => this.ExportFromSpecifier(reducer, v)) });
|
||||
},
|
||||
|
||||
ExportFromSpecifier(reducer, node) {
|
||||
return reducer.reduceExportFromSpecifier(node);
|
||||
},
|
||||
|
||||
ExportLocalSpecifier(reducer, node) {
|
||||
return reducer.reduceExportLocalSpecifier(node, { name: this.IdentifierExpression(reducer, node.name) });
|
||||
},
|
||||
|
||||
ExportLocals(reducer, node) {
|
||||
return reducer.reduceExportLocals(node, { namedExports: node.namedExports.map(v => this.ExportLocalSpecifier(reducer, v)) });
|
||||
},
|
||||
|
||||
ExpressionStatement(reducer, node) {
|
||||
return reducer.reduceExpressionStatement(node, { expression: this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
|
||||
ForAwaitStatement(reducer, node) {
|
||||
return reducer.reduceForAwaitStatement(node, { left: this[node.left.type](reducer, node.left), right: this[node.right.type](reducer, node.right), body: this[node.body.type](reducer, node.body) });
|
||||
},
|
||||
|
||||
ForInStatement(reducer, node) {
|
||||
return reducer.reduceForInStatement(node, { left: this[node.left.type](reducer, node.left), right: this[node.right.type](reducer, node.right), body: this[node.body.type](reducer, node.body) });
|
||||
},
|
||||
|
||||
ForOfStatement(reducer, node) {
|
||||
return reducer.reduceForOfStatement(node, { left: this[node.left.type](reducer, node.left), right: this[node.right.type](reducer, node.right), body: this[node.body.type](reducer, node.body) });
|
||||
},
|
||||
|
||||
ForStatement(reducer, node) {
|
||||
return reducer.reduceForStatement(node, { init: node.init && this[node.init.type](reducer, node.init), test: node.test && this[node.test.type](reducer, node.test), update: node.update && this[node.update.type](reducer, node.update), body: this[node.body.type](reducer, node.body) });
|
||||
},
|
||||
|
||||
FormalParameters(reducer, node) {
|
||||
return reducer.reduceFormalParameters(node, { items: node.items.map(v => this[v.type](reducer, v)), rest: node.rest && this[node.rest.type](reducer, node.rest) });
|
||||
},
|
||||
|
||||
FunctionBody(reducer, node) {
|
||||
return reducer.reduceFunctionBody(node, { directives: node.directives.map(v => this.Directive(reducer, v)), statements: node.statements.map(v => this[v.type](reducer, v)) });
|
||||
},
|
||||
|
||||
FunctionDeclaration(reducer, node) {
|
||||
return reducer.reduceFunctionDeclaration(node, { name: this.BindingIdentifier(reducer, node.name), params: this.FormalParameters(reducer, node.params), body: this.FunctionBody(reducer, node.body) });
|
||||
},
|
||||
|
||||
FunctionExpression(reducer, node) {
|
||||
return reducer.reduceFunctionExpression(node, { name: node.name && this.BindingIdentifier(reducer, node.name), params: this.FormalParameters(reducer, node.params), body: this.FunctionBody(reducer, node.body) });
|
||||
},
|
||||
|
||||
Getter(reducer, node) {
|
||||
return reducer.reduceGetter(node, { name: this[node.name.type](reducer, node.name), body: this.FunctionBody(reducer, node.body) });
|
||||
},
|
||||
|
||||
IdentifierExpression(reducer, node) {
|
||||
return reducer.reduceIdentifierExpression(node);
|
||||
},
|
||||
|
||||
IfStatement(reducer, node) {
|
||||
return reducer.reduceIfStatement(node, { test: this[node.test.type](reducer, node.test), consequent: this[node.consequent.type](reducer, node.consequent), alternate: node.alternate && this[node.alternate.type](reducer, node.alternate) });
|
||||
},
|
||||
|
||||
Import(reducer, node) {
|
||||
return reducer.reduceImport(node, { defaultBinding: node.defaultBinding && this.BindingIdentifier(reducer, node.defaultBinding), namedImports: node.namedImports.map(v => this.ImportSpecifier(reducer, v)) });
|
||||
},
|
||||
|
||||
ImportNamespace(reducer, node) {
|
||||
return reducer.reduceImportNamespace(node, { defaultBinding: node.defaultBinding && this.BindingIdentifier(reducer, node.defaultBinding), namespaceBinding: this.BindingIdentifier(reducer, node.namespaceBinding) });
|
||||
},
|
||||
|
||||
ImportSpecifier(reducer, node) {
|
||||
return reducer.reduceImportSpecifier(node, { binding: this.BindingIdentifier(reducer, node.binding) });
|
||||
},
|
||||
|
||||
LabeledStatement(reducer, node) {
|
||||
return reducer.reduceLabeledStatement(node, { body: this[node.body.type](reducer, node.body) });
|
||||
},
|
||||
|
||||
LiteralBooleanExpression(reducer, node) {
|
||||
return reducer.reduceLiteralBooleanExpression(node);
|
||||
},
|
||||
|
||||
LiteralInfinityExpression(reducer, node) {
|
||||
return reducer.reduceLiteralInfinityExpression(node);
|
||||
},
|
||||
|
||||
LiteralNullExpression(reducer, node) {
|
||||
return reducer.reduceLiteralNullExpression(node);
|
||||
},
|
||||
|
||||
LiteralNumericExpression(reducer, node) {
|
||||
return reducer.reduceLiteralNumericExpression(node);
|
||||
},
|
||||
|
||||
LiteralRegExpExpression(reducer, node) {
|
||||
return reducer.reduceLiteralRegExpExpression(node);
|
||||
},
|
||||
|
||||
LiteralStringExpression(reducer, node) {
|
||||
return reducer.reduceLiteralStringExpression(node);
|
||||
},
|
||||
|
||||
Method(reducer, node) {
|
||||
return reducer.reduceMethod(node, { name: this[node.name.type](reducer, node.name), params: this.FormalParameters(reducer, node.params), body: this.FunctionBody(reducer, node.body) });
|
||||
},
|
||||
|
||||
Module(reducer, node) {
|
||||
return reducer.reduceModule(node, { directives: node.directives.map(v => this.Directive(reducer, v)), items: node.items.map(v => this[v.type](reducer, v)) });
|
||||
},
|
||||
|
||||
NewExpression(reducer, node) {
|
||||
return reducer.reduceNewExpression(node, { callee: this[node.callee.type](reducer, node.callee), arguments: node.arguments.map(v => this[v.type](reducer, v)) });
|
||||
},
|
||||
|
||||
NewTargetExpression(reducer, node) {
|
||||
return reducer.reduceNewTargetExpression(node);
|
||||
},
|
||||
|
||||
ObjectAssignmentTarget(reducer, node) {
|
||||
return reducer.reduceObjectAssignmentTarget(node, { properties: node.properties.map(v => this[v.type](reducer, v)), rest: node.rest && this[node.rest.type](reducer, node.rest) });
|
||||
},
|
||||
|
||||
ObjectBinding(reducer, node) {
|
||||
return reducer.reduceObjectBinding(node, { properties: node.properties.map(v => this[v.type](reducer, v)), rest: node.rest && this[node.rest.type](reducer, node.rest) });
|
||||
},
|
||||
|
||||
ObjectExpression(reducer, node) {
|
||||
return reducer.reduceObjectExpression(node, { properties: node.properties.map(v => this[v.type](reducer, v)) });
|
||||
},
|
||||
|
||||
ReturnStatement(reducer, node) {
|
||||
return reducer.reduceReturnStatement(node, { expression: node.expression && this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
|
||||
Script(reducer, node) {
|
||||
return reducer.reduceScript(node, { directives: node.directives.map(v => this.Directive(reducer, v)), statements: node.statements.map(v => this[v.type](reducer, v)) });
|
||||
},
|
||||
|
||||
Setter(reducer, node) {
|
||||
return reducer.reduceSetter(node, { name: this[node.name.type](reducer, node.name), param: this[node.param.type](reducer, node.param), body: this.FunctionBody(reducer, node.body) });
|
||||
},
|
||||
|
||||
ShorthandProperty(reducer, node) {
|
||||
return reducer.reduceShorthandProperty(node, { name: this.IdentifierExpression(reducer, node.name) });
|
||||
},
|
||||
|
||||
SpreadElement(reducer, node) {
|
||||
return reducer.reduceSpreadElement(node, { expression: this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
|
||||
SpreadProperty(reducer, node) {
|
||||
return reducer.reduceSpreadProperty(node, { expression: this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
|
||||
StaticMemberAssignmentTarget(reducer, node) {
|
||||
return reducer.reduceStaticMemberAssignmentTarget(node, { object: this[node.object.type](reducer, node.object) });
|
||||
},
|
||||
|
||||
StaticMemberExpression(reducer, node) {
|
||||
return reducer.reduceStaticMemberExpression(node, { object: this[node.object.type](reducer, node.object) });
|
||||
},
|
||||
|
||||
StaticPropertyName(reducer, node) {
|
||||
return reducer.reduceStaticPropertyName(node);
|
||||
},
|
||||
|
||||
Super(reducer, node) {
|
||||
return reducer.reduceSuper(node);
|
||||
},
|
||||
|
||||
SwitchCase(reducer, node) {
|
||||
return reducer.reduceSwitchCase(node, { test: this[node.test.type](reducer, node.test), consequent: node.consequent.map(v => this[v.type](reducer, v)) });
|
||||
},
|
||||
|
||||
SwitchDefault(reducer, node) {
|
||||
return reducer.reduceSwitchDefault(node, { consequent: node.consequent.map(v => this[v.type](reducer, v)) });
|
||||
},
|
||||
|
||||
SwitchStatement(reducer, node) {
|
||||
return reducer.reduceSwitchStatement(node, { discriminant: this[node.discriminant.type](reducer, node.discriminant), cases: node.cases.map(v => this.SwitchCase(reducer, v)) });
|
||||
},
|
||||
|
||||
SwitchStatementWithDefault(reducer, node) {
|
||||
return reducer.reduceSwitchStatementWithDefault(node, { discriminant: this[node.discriminant.type](reducer, node.discriminant), preDefaultCases: node.preDefaultCases.map(v => this.SwitchCase(reducer, v)), defaultCase: this.SwitchDefault(reducer, node.defaultCase), postDefaultCases: node.postDefaultCases.map(v => this.SwitchCase(reducer, v)) });
|
||||
},
|
||||
|
||||
TemplateElement(reducer, node) {
|
||||
return reducer.reduceTemplateElement(node);
|
||||
},
|
||||
|
||||
TemplateExpression(reducer, node) {
|
||||
return reducer.reduceTemplateExpression(node, { tag: node.tag && this[node.tag.type](reducer, node.tag), elements: node.elements.map(v => this[v.type](reducer, v)) });
|
||||
},
|
||||
|
||||
ThisExpression(reducer, node) {
|
||||
return reducer.reduceThisExpression(node);
|
||||
},
|
||||
|
||||
ThrowStatement(reducer, node) {
|
||||
return reducer.reduceThrowStatement(node, { expression: this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
|
||||
TryCatchStatement(reducer, node) {
|
||||
return reducer.reduceTryCatchStatement(node, { body: this.Block(reducer, node.body), catchClause: this.CatchClause(reducer, node.catchClause) });
|
||||
},
|
||||
|
||||
TryFinallyStatement(reducer, node) {
|
||||
return reducer.reduceTryFinallyStatement(node, { body: this.Block(reducer, node.body), catchClause: node.catchClause && this.CatchClause(reducer, node.catchClause), finalizer: this.Block(reducer, node.finalizer) });
|
||||
},
|
||||
|
||||
UnaryExpression(reducer, node) {
|
||||
return reducer.reduceUnaryExpression(node, { operand: this[node.operand.type](reducer, node.operand) });
|
||||
},
|
||||
|
||||
UpdateExpression(reducer, node) {
|
||||
return reducer.reduceUpdateExpression(node, { operand: this[node.operand.type](reducer, node.operand) });
|
||||
},
|
||||
|
||||
VariableDeclaration(reducer, node) {
|
||||
return reducer.reduceVariableDeclaration(node, { declarators: node.declarators.map(v => this.VariableDeclarator(reducer, v)) });
|
||||
},
|
||||
|
||||
VariableDeclarationStatement(reducer, node) {
|
||||
return reducer.reduceVariableDeclarationStatement(node, { declaration: this.VariableDeclaration(reducer, node.declaration) });
|
||||
},
|
||||
|
||||
VariableDeclarator(reducer, node) {
|
||||
return reducer.reduceVariableDeclarator(node, { binding: this[node.binding.type](reducer, node.binding), init: node.init && this[node.init.type](reducer, node.init) });
|
||||
},
|
||||
|
||||
WhileStatement(reducer, node) {
|
||||
return reducer.reduceWhileStatement(node, { test: this[node.test.type](reducer, node.test), body: this[node.body.type](reducer, node.body) });
|
||||
},
|
||||
|
||||
WithStatement(reducer, node) {
|
||||
return reducer.reduceWithStatement(node, { object: this[node.object.type](reducer, node.object), body: this[node.body.type](reducer, node.body) });
|
||||
},
|
||||
|
||||
YieldExpression(reducer, node) {
|
||||
return reducer.reduceYieldExpression(node, { expression: node.expression && this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
|
||||
YieldGeneratorExpression(reducer, node) {
|
||||
return reducer.reduceYieldGeneratorExpression(node, { expression: this[node.expression.type](reducer, node.expression) });
|
||||
},
|
||||
};
|
||||
|
||||
export function reduce(reducer, node) {
|
||||
return director[node.type](reducer, node);
|
||||
}
|
||||
27
docs/dist/shift-reducer/index.js
vendored
27
docs/dist/shift-reducer/index.js
vendored
@ -1,27 +0,0 @@
|
||||
/*
|
||||
* Copyright 2018 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
export { reduce, reduce as default } from './director.js';
|
||||
export { thunkedReduce } from './thunked-director.js';
|
||||
export { default as thunkify } from './thunkify.js';
|
||||
export { default as thunkifyClass } from './thunkify-class.js';
|
||||
export { default as memoize } from './memoize.js';
|
||||
export { default as CloneReducer } from './clone-reducer.js';
|
||||
export { default as LazyCloneReducer } from './lazy-clone-reducer.js';
|
||||
export { default as MonoidalReducer } from './monoidal-reducer.js';
|
||||
export { default as ThunkedMonoidalReducer } from './thunked-monoidal-reducer.js';
|
||||
export { default as adapt } from './adapt.js';
|
||||
export { PlusReducer, ThunkedPlusReducer, ConcatReducer, ThunkedConcatReducer, AndReducer, ThunkedAndReducer, OrReducer, ThunkedOrReducer } from './reducers.js';
|
||||
650
docs/dist/shift-reducer/lazy-clone-reducer.js
vendored
650
docs/dist/shift-reducer/lazy-clone-reducer.js
vendored
@ -1,650 +0,0 @@
|
||||
// Generated by generate-lazy-clone-reducer.js
|
||||
/**
|
||||
* Copyright 2018 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import * as Shift from '../../_snowpack/pkg/shift-ast.js';
|
||||
|
||||
export default class LazyCloneReducer {
|
||||
reduceArrayAssignmentTarget(node, { elements, rest }) {
|
||||
if ((node.elements.length === elements.length && node.elements.every((v, i) => v === elements[i])) && node.rest === rest) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ArrayAssignmentTarget({ elements, rest });
|
||||
}
|
||||
|
||||
reduceArrayBinding(node, { elements, rest }) {
|
||||
if ((node.elements.length === elements.length && node.elements.every((v, i) => v === elements[i])) && node.rest === rest) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ArrayBinding({ elements, rest });
|
||||
}
|
||||
|
||||
reduceArrayExpression(node, { elements }) {
|
||||
if ((node.elements.length === elements.length && node.elements.every((v, i) => v === elements[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ArrayExpression({ elements });
|
||||
}
|
||||
|
||||
reduceArrowExpression(node, { params, body }) {
|
||||
if (node.params === params && node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ArrowExpression({ isAsync: node.isAsync, params, body });
|
||||
}
|
||||
|
||||
reduceAssignmentExpression(node, { binding, expression }) {
|
||||
if (node.binding === binding && node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.AssignmentExpression({ binding, expression });
|
||||
}
|
||||
|
||||
reduceAssignmentTargetIdentifier(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceAssignmentTargetPropertyIdentifier(node, { binding, init }) {
|
||||
if (node.binding === binding && node.init === init) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.AssignmentTargetPropertyIdentifier({ binding, init });
|
||||
}
|
||||
|
||||
reduceAssignmentTargetPropertyProperty(node, { name, binding }) {
|
||||
if (node.name === name && node.binding === binding) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.AssignmentTargetPropertyProperty({ name, binding });
|
||||
}
|
||||
|
||||
reduceAssignmentTargetWithDefault(node, { binding, init }) {
|
||||
if (node.binding === binding && node.init === init) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.AssignmentTargetWithDefault({ binding, init });
|
||||
}
|
||||
|
||||
reduceAwaitExpression(node, { expression }) {
|
||||
if (node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.AwaitExpression({ expression });
|
||||
}
|
||||
|
||||
reduceBinaryExpression(node, { left, right }) {
|
||||
if (node.left === left && node.right === right) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.BinaryExpression({ left, operator: node.operator, right });
|
||||
}
|
||||
|
||||
reduceBindingIdentifier(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceBindingPropertyIdentifier(node, { binding, init }) {
|
||||
if (node.binding === binding && node.init === init) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.BindingPropertyIdentifier({ binding, init });
|
||||
}
|
||||
|
||||
reduceBindingPropertyProperty(node, { name, binding }) {
|
||||
if (node.name === name && node.binding === binding) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.BindingPropertyProperty({ name, binding });
|
||||
}
|
||||
|
||||
reduceBindingWithDefault(node, { binding, init }) {
|
||||
if (node.binding === binding && node.init === init) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.BindingWithDefault({ binding, init });
|
||||
}
|
||||
|
||||
reduceBlock(node, { statements }) {
|
||||
if ((node.statements.length === statements.length && node.statements.every((v, i) => v === statements[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.Block({ statements });
|
||||
}
|
||||
|
||||
reduceBlockStatement(node, { block }) {
|
||||
if (node.block === block) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.BlockStatement({ block });
|
||||
}
|
||||
|
||||
reduceBreakStatement(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceCallExpression(node, { callee, arguments: _arguments }) {
|
||||
if (node.callee === callee && (node.arguments.length === _arguments.length && node.arguments.every((v, i) => v === _arguments[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.CallExpression({ callee, arguments: _arguments });
|
||||
}
|
||||
|
||||
reduceCatchClause(node, { binding, body }) {
|
||||
if (node.binding === binding && node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.CatchClause({ binding, body });
|
||||
}
|
||||
|
||||
reduceClassDeclaration(node, { name, super: _super, elements }) {
|
||||
if (node.name === name && node.super === _super && (node.elements.length === elements.length && node.elements.every((v, i) => v === elements[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ClassDeclaration({ name, super: _super, elements });
|
||||
}
|
||||
|
||||
reduceClassElement(node, { method }) {
|
||||
if (node.method === method) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ClassElement({ isStatic: node.isStatic, method });
|
||||
}
|
||||
|
||||
reduceClassExpression(node, { name, super: _super, elements }) {
|
||||
if (node.name === name && node.super === _super && (node.elements.length === elements.length && node.elements.every((v, i) => v === elements[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ClassExpression({ name, super: _super, elements });
|
||||
}
|
||||
|
||||
reduceCompoundAssignmentExpression(node, { binding, expression }) {
|
||||
if (node.binding === binding && node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.CompoundAssignmentExpression({ binding, operator: node.operator, expression });
|
||||
}
|
||||
|
||||
reduceComputedMemberAssignmentTarget(node, { object, expression }) {
|
||||
if (node.object === object && node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ComputedMemberAssignmentTarget({ object, expression });
|
||||
}
|
||||
|
||||
reduceComputedMemberExpression(node, { object, expression }) {
|
||||
if (node.object === object && node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ComputedMemberExpression({ object, expression });
|
||||
}
|
||||
|
||||
reduceComputedPropertyName(node, { expression }) {
|
||||
if (node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ComputedPropertyName({ expression });
|
||||
}
|
||||
|
||||
reduceConditionalExpression(node, { test, consequent, alternate }) {
|
||||
if (node.test === test && node.consequent === consequent && node.alternate === alternate) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ConditionalExpression({ test, consequent, alternate });
|
||||
}
|
||||
|
||||
reduceContinueStatement(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceDataProperty(node, { name, expression }) {
|
||||
if (node.name === name && node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.DataProperty({ name, expression });
|
||||
}
|
||||
|
||||
reduceDebuggerStatement(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceDirective(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceDoWhileStatement(node, { body, test }) {
|
||||
if (node.body === body && node.test === test) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.DoWhileStatement({ body, test });
|
||||
}
|
||||
|
||||
reduceEmptyStatement(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceExport(node, { declaration }) {
|
||||
if (node.declaration === declaration) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.Export({ declaration });
|
||||
}
|
||||
|
||||
reduceExportAllFrom(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceExportDefault(node, { body }) {
|
||||
if (node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ExportDefault({ body });
|
||||
}
|
||||
|
||||
reduceExportFrom(node, { namedExports }) {
|
||||
if ((node.namedExports.length === namedExports.length && node.namedExports.every((v, i) => v === namedExports[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ExportFrom({ namedExports, moduleSpecifier: node.moduleSpecifier });
|
||||
}
|
||||
|
||||
reduceExportFromSpecifier(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceExportLocalSpecifier(node, { name }) {
|
||||
if (node.name === name) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ExportLocalSpecifier({ name, exportedName: node.exportedName });
|
||||
}
|
||||
|
||||
reduceExportLocals(node, { namedExports }) {
|
||||
if ((node.namedExports.length === namedExports.length && node.namedExports.every((v, i) => v === namedExports[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ExportLocals({ namedExports });
|
||||
}
|
||||
|
||||
reduceExpressionStatement(node, { expression }) {
|
||||
if (node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ExpressionStatement({ expression });
|
||||
}
|
||||
|
||||
reduceForAwaitStatement(node, { left, right, body }) {
|
||||
if (node.left === left && node.right === right && node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ForAwaitStatement({ left, right, body });
|
||||
}
|
||||
|
||||
reduceForInStatement(node, { left, right, body }) {
|
||||
if (node.left === left && node.right === right && node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ForInStatement({ left, right, body });
|
||||
}
|
||||
|
||||
reduceForOfStatement(node, { left, right, body }) {
|
||||
if (node.left === left && node.right === right && node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ForOfStatement({ left, right, body });
|
||||
}
|
||||
|
||||
reduceForStatement(node, { init, test, update, body }) {
|
||||
if (node.init === init && node.test === test && node.update === update && node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ForStatement({ init, test, update, body });
|
||||
}
|
||||
|
||||
reduceFormalParameters(node, { items, rest }) {
|
||||
if ((node.items.length === items.length && node.items.every((v, i) => v === items[i])) && node.rest === rest) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.FormalParameters({ items, rest });
|
||||
}
|
||||
|
||||
reduceFunctionBody(node, { directives, statements }) {
|
||||
if ((node.directives.length === directives.length && node.directives.every((v, i) => v === directives[i])) && (node.statements.length === statements.length && node.statements.every((v, i) => v === statements[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.FunctionBody({ directives, statements });
|
||||
}
|
||||
|
||||
reduceFunctionDeclaration(node, { name, params, body }) {
|
||||
if (node.name === name && node.params === params && node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.FunctionDeclaration({ isAsync: node.isAsync, isGenerator: node.isGenerator, name, params, body });
|
||||
}
|
||||
|
||||
reduceFunctionExpression(node, { name, params, body }) {
|
||||
if (node.name === name && node.params === params && node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.FunctionExpression({ isAsync: node.isAsync, isGenerator: node.isGenerator, name, params, body });
|
||||
}
|
||||
|
||||
reduceGetter(node, { name, body }) {
|
||||
if (node.name === name && node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.Getter({ name, body });
|
||||
}
|
||||
|
||||
reduceIdentifierExpression(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceIfStatement(node, { test, consequent, alternate }) {
|
||||
if (node.test === test && node.consequent === consequent && node.alternate === alternate) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.IfStatement({ test, consequent, alternate });
|
||||
}
|
||||
|
||||
reduceImport(node, { defaultBinding, namedImports }) {
|
||||
if (node.defaultBinding === defaultBinding && (node.namedImports.length === namedImports.length && node.namedImports.every((v, i) => v === namedImports[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.Import({ defaultBinding, namedImports, moduleSpecifier: node.moduleSpecifier });
|
||||
}
|
||||
|
||||
reduceImportNamespace(node, { defaultBinding, namespaceBinding }) {
|
||||
if (node.defaultBinding === defaultBinding && node.namespaceBinding === namespaceBinding) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ImportNamespace({ defaultBinding, namespaceBinding, moduleSpecifier: node.moduleSpecifier });
|
||||
}
|
||||
|
||||
reduceImportSpecifier(node, { binding }) {
|
||||
if (node.binding === binding) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ImportSpecifier({ name: node.name, binding });
|
||||
}
|
||||
|
||||
reduceLabeledStatement(node, { body }) {
|
||||
if (node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.LabeledStatement({ label: node.label, body });
|
||||
}
|
||||
|
||||
reduceLiteralBooleanExpression(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceLiteralInfinityExpression(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceLiteralNullExpression(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceLiteralNumericExpression(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceLiteralRegExpExpression(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceLiteralStringExpression(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceMethod(node, { name, params, body }) {
|
||||
if (node.name === name && node.params === params && node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.Method({ isAsync: node.isAsync, isGenerator: node.isGenerator, name, params, body });
|
||||
}
|
||||
|
||||
reduceModule(node, { directives, items }) {
|
||||
if ((node.directives.length === directives.length && node.directives.every((v, i) => v === directives[i])) && (node.items.length === items.length && node.items.every((v, i) => v === items[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.Module({ directives, items });
|
||||
}
|
||||
|
||||
reduceNewExpression(node, { callee, arguments: _arguments }) {
|
||||
if (node.callee === callee && (node.arguments.length === _arguments.length && node.arguments.every((v, i) => v === _arguments[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.NewExpression({ callee, arguments: _arguments });
|
||||
}
|
||||
|
||||
reduceNewTargetExpression(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceObjectAssignmentTarget(node, { properties, rest }) {
|
||||
if ((node.properties.length === properties.length && node.properties.every((v, i) => v === properties[i])) && node.rest === rest) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ObjectAssignmentTarget({ properties, rest });
|
||||
}
|
||||
|
||||
reduceObjectBinding(node, { properties, rest }) {
|
||||
if ((node.properties.length === properties.length && node.properties.every((v, i) => v === properties[i])) && node.rest === rest) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ObjectBinding({ properties, rest });
|
||||
}
|
||||
|
||||
reduceObjectExpression(node, { properties }) {
|
||||
if ((node.properties.length === properties.length && node.properties.every((v, i) => v === properties[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ObjectExpression({ properties });
|
||||
}
|
||||
|
||||
reduceReturnStatement(node, { expression }) {
|
||||
if (node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ReturnStatement({ expression });
|
||||
}
|
||||
|
||||
reduceScript(node, { directives, statements }) {
|
||||
if ((node.directives.length === directives.length && node.directives.every((v, i) => v === directives[i])) && (node.statements.length === statements.length && node.statements.every((v, i) => v === statements[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.Script({ directives, statements });
|
||||
}
|
||||
|
||||
reduceSetter(node, { name, param, body }) {
|
||||
if (node.name === name && node.param === param && node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.Setter({ name, param, body });
|
||||
}
|
||||
|
||||
reduceShorthandProperty(node, { name }) {
|
||||
if (node.name === name) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ShorthandProperty({ name });
|
||||
}
|
||||
|
||||
reduceSpreadElement(node, { expression }) {
|
||||
if (node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.SpreadElement({ expression });
|
||||
}
|
||||
|
||||
reduceSpreadProperty(node, { expression }) {
|
||||
if (node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.SpreadProperty({ expression });
|
||||
}
|
||||
|
||||
reduceStaticMemberAssignmentTarget(node, { object }) {
|
||||
if (node.object === object) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.StaticMemberAssignmentTarget({ object, property: node.property });
|
||||
}
|
||||
|
||||
reduceStaticMemberExpression(node, { object }) {
|
||||
if (node.object === object) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.StaticMemberExpression({ object, property: node.property });
|
||||
}
|
||||
|
||||
reduceStaticPropertyName(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceSuper(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceSwitchCase(node, { test, consequent }) {
|
||||
if (node.test === test && (node.consequent.length === consequent.length && node.consequent.every((v, i) => v === consequent[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.SwitchCase({ test, consequent });
|
||||
}
|
||||
|
||||
reduceSwitchDefault(node, { consequent }) {
|
||||
if ((node.consequent.length === consequent.length && node.consequent.every((v, i) => v === consequent[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.SwitchDefault({ consequent });
|
||||
}
|
||||
|
||||
reduceSwitchStatement(node, { discriminant, cases }) {
|
||||
if (node.discriminant === discriminant && (node.cases.length === cases.length && node.cases.every((v, i) => v === cases[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.SwitchStatement({ discriminant, cases });
|
||||
}
|
||||
|
||||
reduceSwitchStatementWithDefault(node, { discriminant, preDefaultCases, defaultCase, postDefaultCases }) {
|
||||
if (node.discriminant === discriminant && (node.preDefaultCases.length === preDefaultCases.length && node.preDefaultCases.every((v, i) => v === preDefaultCases[i])) && node.defaultCase === defaultCase && (node.postDefaultCases.length === postDefaultCases.length && node.postDefaultCases.every((v, i) => v === postDefaultCases[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.SwitchStatementWithDefault({ discriminant, preDefaultCases, defaultCase, postDefaultCases });
|
||||
}
|
||||
|
||||
reduceTemplateElement(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceTemplateExpression(node, { tag, elements }) {
|
||||
if (node.tag === tag && (node.elements.length === elements.length && node.elements.every((v, i) => v === elements[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.TemplateExpression({ tag, elements });
|
||||
}
|
||||
|
||||
reduceThisExpression(node) {
|
||||
return node;
|
||||
}
|
||||
|
||||
reduceThrowStatement(node, { expression }) {
|
||||
if (node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.ThrowStatement({ expression });
|
||||
}
|
||||
|
||||
reduceTryCatchStatement(node, { body, catchClause }) {
|
||||
if (node.body === body && node.catchClause === catchClause) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.TryCatchStatement({ body, catchClause });
|
||||
}
|
||||
|
||||
reduceTryFinallyStatement(node, { body, catchClause, finalizer }) {
|
||||
if (node.body === body && node.catchClause === catchClause && node.finalizer === finalizer) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.TryFinallyStatement({ body, catchClause, finalizer });
|
||||
}
|
||||
|
||||
reduceUnaryExpression(node, { operand }) {
|
||||
if (node.operand === operand) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.UnaryExpression({ operator: node.operator, operand });
|
||||
}
|
||||
|
||||
reduceUpdateExpression(node, { operand }) {
|
||||
if (node.operand === operand) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.UpdateExpression({ isPrefix: node.isPrefix, operator: node.operator, operand });
|
||||
}
|
||||
|
||||
reduceVariableDeclaration(node, { declarators }) {
|
||||
if ((node.declarators.length === declarators.length && node.declarators.every((v, i) => v === declarators[i]))) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.VariableDeclaration({ kind: node.kind, declarators });
|
||||
}
|
||||
|
||||
reduceVariableDeclarationStatement(node, { declaration }) {
|
||||
if (node.declaration === declaration) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.VariableDeclarationStatement({ declaration });
|
||||
}
|
||||
|
||||
reduceVariableDeclarator(node, { binding, init }) {
|
||||
if (node.binding === binding && node.init === init) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.VariableDeclarator({ binding, init });
|
||||
}
|
||||
|
||||
reduceWhileStatement(node, { test, body }) {
|
||||
if (node.test === test && node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.WhileStatement({ test, body });
|
||||
}
|
||||
|
||||
reduceWithStatement(node, { object, body }) {
|
||||
if (node.object === object && node.body === body) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.WithStatement({ object, body });
|
||||
}
|
||||
|
||||
reduceYieldExpression(node, { expression }) {
|
||||
if (node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.YieldExpression({ expression });
|
||||
}
|
||||
|
||||
reduceYieldGeneratorExpression(node, { expression }) {
|
||||
if (node.expression === expression) {
|
||||
return node;
|
||||
}
|
||||
return new Shift.YieldGeneratorExpression({ expression });
|
||||
}
|
||||
}
|
||||
914
docs/dist/shift-reducer/memoize.js
vendored
914
docs/dist/shift-reducer/memoize.js
vendored
@ -1,914 +0,0 @@
|
||||
// Generated by generate-memoize.js
|
||||
/**
|
||||
* Copyright 2018 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import * as Shift from '../../_snowpack/pkg/shift-ast.js';
|
||||
|
||||
export default function memoize(reducer) {
|
||||
const cache = new WeakMap;
|
||||
return {
|
||||
reduceArrayAssignmentTarget(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceArrayAssignmentTarget(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceArrayBinding(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceArrayBinding(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceArrayExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceArrayExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceArrowExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceArrowExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceAssignmentExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceAssignmentExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceAssignmentTargetIdentifier(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceAssignmentTargetIdentifier(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceAssignmentTargetPropertyIdentifier(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceAssignmentTargetPropertyIdentifier(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceAssignmentTargetPropertyProperty(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceAssignmentTargetPropertyProperty(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceAssignmentTargetWithDefault(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceAssignmentTargetWithDefault(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceAwaitExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceAwaitExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceBinaryExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceBinaryExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceBindingIdentifier(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceBindingIdentifier(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceBindingPropertyIdentifier(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceBindingPropertyIdentifier(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceBindingPropertyProperty(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceBindingPropertyProperty(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceBindingWithDefault(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceBindingWithDefault(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceBlock(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceBlock(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceBlockStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceBlockStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceBreakStatement(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceBreakStatement(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceCallExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceCallExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceCatchClause(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceCatchClause(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceClassDeclaration(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceClassDeclaration(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceClassElement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceClassElement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceClassExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceClassExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceCompoundAssignmentExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceCompoundAssignmentExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceComputedMemberAssignmentTarget(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceComputedMemberAssignmentTarget(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceComputedMemberExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceComputedMemberExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceComputedPropertyName(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceComputedPropertyName(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceConditionalExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceConditionalExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceContinueStatement(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceContinueStatement(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceDataProperty(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceDataProperty(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceDebuggerStatement(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceDebuggerStatement(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceDirective(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceDirective(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceDoWhileStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceDoWhileStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceEmptyStatement(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceEmptyStatement(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceExport(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceExport(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceExportAllFrom(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceExportAllFrom(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceExportDefault(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceExportDefault(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceExportFrom(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceExportFrom(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceExportFromSpecifier(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceExportFromSpecifier(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceExportLocalSpecifier(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceExportLocalSpecifier(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceExportLocals(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceExportLocals(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceExpressionStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceExpressionStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceForAwaitStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceForAwaitStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceForInStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceForInStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceForOfStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceForOfStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceForStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceForStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceFormalParameters(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceFormalParameters(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceFunctionBody(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceFunctionBody(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceFunctionDeclaration(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceFunctionDeclaration(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceFunctionExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceFunctionExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceGetter(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceGetter(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceIdentifierExpression(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceIdentifierExpression(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceIfStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceIfStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceImport(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceImport(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceImportNamespace(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceImportNamespace(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceImportSpecifier(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceImportSpecifier(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceLabeledStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceLabeledStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceLiteralBooleanExpression(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceLiteralBooleanExpression(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceLiteralInfinityExpression(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceLiteralInfinityExpression(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceLiteralNullExpression(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceLiteralNullExpression(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceLiteralNumericExpression(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceLiteralNumericExpression(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceLiteralRegExpExpression(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceLiteralRegExpExpression(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceLiteralStringExpression(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceLiteralStringExpression(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceMethod(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceMethod(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceModule(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceModule(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceNewExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceNewExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceNewTargetExpression(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceNewTargetExpression(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceObjectAssignmentTarget(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceObjectAssignmentTarget(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceObjectBinding(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceObjectBinding(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceObjectExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceObjectExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceReturnStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceReturnStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceScript(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceScript(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceSetter(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceSetter(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceShorthandProperty(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceShorthandProperty(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceSpreadElement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceSpreadElement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceSpreadProperty(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceSpreadProperty(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceStaticMemberAssignmentTarget(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceStaticMemberAssignmentTarget(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceStaticMemberExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceStaticMemberExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceStaticPropertyName(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceStaticPropertyName(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceSuper(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceSuper(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceSwitchCase(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceSwitchCase(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceSwitchDefault(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceSwitchDefault(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceSwitchStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceSwitchStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceSwitchStatementWithDefault(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceSwitchStatementWithDefault(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceTemplateElement(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceTemplateElement(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceTemplateExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceTemplateExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceThisExpression(node) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceThisExpression(node);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceThrowStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceThrowStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceTryCatchStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceTryCatchStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceTryFinallyStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceTryFinallyStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceUnaryExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceUnaryExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceUpdateExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceUpdateExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceVariableDeclaration(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceVariableDeclaration(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceVariableDeclarationStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceVariableDeclarationStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceVariableDeclarator(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceVariableDeclarator(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceWhileStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceWhileStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceWithStatement(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceWithStatement(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceYieldExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceYieldExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
|
||||
reduceYieldGeneratorExpression(node, arg) {
|
||||
if (cache.has(node)) {
|
||||
return cache.get(node);
|
||||
}
|
||||
const res = reducer.reduceYieldGeneratorExpression(node, arg);
|
||||
cache.set(node, res);
|
||||
return res;
|
||||
},
|
||||
};
|
||||
}
|
||||
430
docs/dist/shift-reducer/monoidal-reducer.js
vendored
430
docs/dist/shift-reducer/monoidal-reducer.js
vendored
@ -1,430 +0,0 @@
|
||||
// Generated by generate-monoidal-reducer.js
|
||||
/**
|
||||
* Copyright 2018 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import Shift from '../../_snowpack/pkg/shift-ast.js';
|
||||
|
||||
export default class MonoidalReducer {
|
||||
constructor(monoid) {
|
||||
let identity = monoid.empty();
|
||||
this.identity = identity;
|
||||
let concat;
|
||||
if (monoid.prototype && typeof monoid.prototype.concat === 'function') {
|
||||
concat = Function.prototype.call.bind(monoid.prototype.concat);
|
||||
} else if (typeof monoid.concat === 'function') {
|
||||
concat = monoid.concat;
|
||||
} else {
|
||||
throw new TypeError('Monoid must provide a `concat` method');
|
||||
}
|
||||
this.append = (...args) => args.reduce(concat, identity);
|
||||
}
|
||||
|
||||
reduceArrayAssignmentTarget(node, { elements, rest }) {
|
||||
return this.append(...elements.filter(n => n != null), rest == null ? this.identity : rest);
|
||||
}
|
||||
|
||||
reduceArrayBinding(node, { elements, rest }) {
|
||||
return this.append(...elements.filter(n => n != null), rest == null ? this.identity : rest);
|
||||
}
|
||||
|
||||
reduceArrayExpression(node, { elements }) {
|
||||
return this.append(...elements.filter(n => n != null));
|
||||
}
|
||||
|
||||
reduceArrowExpression(node, { params, body }) {
|
||||
return this.append(params, body);
|
||||
}
|
||||
|
||||
reduceAssignmentExpression(node, { binding, expression }) {
|
||||
return this.append(binding, expression);
|
||||
}
|
||||
|
||||
reduceAssignmentTargetIdentifier(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceAssignmentTargetPropertyIdentifier(node, { binding, init }) {
|
||||
return this.append(binding, init == null ? this.identity : init);
|
||||
}
|
||||
|
||||
reduceAssignmentTargetPropertyProperty(node, { name, binding }) {
|
||||
return this.append(name, binding);
|
||||
}
|
||||
|
||||
reduceAssignmentTargetWithDefault(node, { binding, init }) {
|
||||
return this.append(binding, init);
|
||||
}
|
||||
|
||||
reduceAwaitExpression(node, { expression }) {
|
||||
return expression;
|
||||
}
|
||||
|
||||
reduceBinaryExpression(node, { left, right }) {
|
||||
return this.append(left, right);
|
||||
}
|
||||
|
||||
reduceBindingIdentifier(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceBindingPropertyIdentifier(node, { binding, init }) {
|
||||
return this.append(binding, init == null ? this.identity : init);
|
||||
}
|
||||
|
||||
reduceBindingPropertyProperty(node, { name, binding }) {
|
||||
return this.append(name, binding);
|
||||
}
|
||||
|
||||
reduceBindingWithDefault(node, { binding, init }) {
|
||||
return this.append(binding, init);
|
||||
}
|
||||
|
||||
reduceBlock(node, { statements }) {
|
||||
return this.append(...statements);
|
||||
}
|
||||
|
||||
reduceBlockStatement(node, { block }) {
|
||||
return block;
|
||||
}
|
||||
|
||||
reduceBreakStatement(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceCallExpression(node, { callee, arguments: _arguments }) {
|
||||
return this.append(callee, ..._arguments);
|
||||
}
|
||||
|
||||
reduceCatchClause(node, { binding, body }) {
|
||||
return this.append(binding, body);
|
||||
}
|
||||
|
||||
reduceClassDeclaration(node, { name, super: _super, elements }) {
|
||||
return this.append(name, _super == null ? this.identity : _super, ...elements);
|
||||
}
|
||||
|
||||
reduceClassElement(node, { method }) {
|
||||
return method;
|
||||
}
|
||||
|
||||
reduceClassExpression(node, { name, super: _super, elements }) {
|
||||
return this.append(name == null ? this.identity : name, _super == null ? this.identity : _super, ...elements);
|
||||
}
|
||||
|
||||
reduceCompoundAssignmentExpression(node, { binding, expression }) {
|
||||
return this.append(binding, expression);
|
||||
}
|
||||
|
||||
reduceComputedMemberAssignmentTarget(node, { object, expression }) {
|
||||
return this.append(object, expression);
|
||||
}
|
||||
|
||||
reduceComputedMemberExpression(node, { object, expression }) {
|
||||
return this.append(object, expression);
|
||||
}
|
||||
|
||||
reduceComputedPropertyName(node, { expression }) {
|
||||
return expression;
|
||||
}
|
||||
|
||||
reduceConditionalExpression(node, { test, consequent, alternate }) {
|
||||
return this.append(test, consequent, alternate);
|
||||
}
|
||||
|
||||
reduceContinueStatement(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceDataProperty(node, { name, expression }) {
|
||||
return this.append(name, expression);
|
||||
}
|
||||
|
||||
reduceDebuggerStatement(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceDirective(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceDoWhileStatement(node, { body, test }) {
|
||||
return this.append(body, test);
|
||||
}
|
||||
|
||||
reduceEmptyStatement(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceExport(node, { declaration }) {
|
||||
return declaration;
|
||||
}
|
||||
|
||||
reduceExportAllFrom(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceExportDefault(node, { body }) {
|
||||
return body;
|
||||
}
|
||||
|
||||
reduceExportFrom(node, { namedExports }) {
|
||||
return this.append(...namedExports);
|
||||
}
|
||||
|
||||
reduceExportFromSpecifier(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceExportLocalSpecifier(node, { name }) {
|
||||
return name;
|
||||
}
|
||||
|
||||
reduceExportLocals(node, { namedExports }) {
|
||||
return this.append(...namedExports);
|
||||
}
|
||||
|
||||
reduceExpressionStatement(node, { expression }) {
|
||||
return expression;
|
||||
}
|
||||
|
||||
reduceForAwaitStatement(node, { left, right, body }) {
|
||||
return this.append(left, right, body);
|
||||
}
|
||||
|
||||
reduceForInStatement(node, { left, right, body }) {
|
||||
return this.append(left, right, body);
|
||||
}
|
||||
|
||||
reduceForOfStatement(node, { left, right, body }) {
|
||||
return this.append(left, right, body);
|
||||
}
|
||||
|
||||
reduceForStatement(node, { init, test, update, body }) {
|
||||
return this.append(init == null ? this.identity : init, test == null ? this.identity : test, update == null ? this.identity : update, body);
|
||||
}
|
||||
|
||||
reduceFormalParameters(node, { items, rest }) {
|
||||
return this.append(...items, rest == null ? this.identity : rest);
|
||||
}
|
||||
|
||||
reduceFunctionBody(node, { directives, statements }) {
|
||||
return this.append(...directives, ...statements);
|
||||
}
|
||||
|
||||
reduceFunctionDeclaration(node, { name, params, body }) {
|
||||
return this.append(name, params, body);
|
||||
}
|
||||
|
||||
reduceFunctionExpression(node, { name, params, body }) {
|
||||
return this.append(name == null ? this.identity : name, params, body);
|
||||
}
|
||||
|
||||
reduceGetter(node, { name, body }) {
|
||||
return this.append(name, body);
|
||||
}
|
||||
|
||||
reduceIdentifierExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceIfStatement(node, { test, consequent, alternate }) {
|
||||
return this.append(test, consequent, alternate == null ? this.identity : alternate);
|
||||
}
|
||||
|
||||
reduceImport(node, { defaultBinding, namedImports }) {
|
||||
return this.append(defaultBinding == null ? this.identity : defaultBinding, ...namedImports);
|
||||
}
|
||||
|
||||
reduceImportNamespace(node, { defaultBinding, namespaceBinding }) {
|
||||
return this.append(defaultBinding == null ? this.identity : defaultBinding, namespaceBinding);
|
||||
}
|
||||
|
||||
reduceImportSpecifier(node, { binding }) {
|
||||
return binding;
|
||||
}
|
||||
|
||||
reduceLabeledStatement(node, { body }) {
|
||||
return body;
|
||||
}
|
||||
|
||||
reduceLiteralBooleanExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceLiteralInfinityExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceLiteralNullExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceLiteralNumericExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceLiteralRegExpExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceLiteralStringExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceMethod(node, { name, params, body }) {
|
||||
return this.append(name, params, body);
|
||||
}
|
||||
|
||||
reduceModule(node, { directives, items }) {
|
||||
return this.append(...directives, ...items);
|
||||
}
|
||||
|
||||
reduceNewExpression(node, { callee, arguments: _arguments }) {
|
||||
return this.append(callee, ..._arguments);
|
||||
}
|
||||
|
||||
reduceNewTargetExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceObjectAssignmentTarget(node, { properties, rest }) {
|
||||
return this.append(...properties, rest == null ? this.identity : rest);
|
||||
}
|
||||
|
||||
reduceObjectBinding(node, { properties, rest }) {
|
||||
return this.append(...properties, rest == null ? this.identity : rest);
|
||||
}
|
||||
|
||||
reduceObjectExpression(node, { properties }) {
|
||||
return this.append(...properties);
|
||||
}
|
||||
|
||||
reduceReturnStatement(node, { expression }) {
|
||||
return expression == null ? this.identity : expression;
|
||||
}
|
||||
|
||||
reduceScript(node, { directives, statements }) {
|
||||
return this.append(...directives, ...statements);
|
||||
}
|
||||
|
||||
reduceSetter(node, { name, param, body }) {
|
||||
return this.append(name, param, body);
|
||||
}
|
||||
|
||||
reduceShorthandProperty(node, { name }) {
|
||||
return name;
|
||||
}
|
||||
|
||||
reduceSpreadElement(node, { expression }) {
|
||||
return expression;
|
||||
}
|
||||
|
||||
reduceSpreadProperty(node, { expression }) {
|
||||
return expression;
|
||||
}
|
||||
|
||||
reduceStaticMemberAssignmentTarget(node, { object }) {
|
||||
return object;
|
||||
}
|
||||
|
||||
reduceStaticMemberExpression(node, { object }) {
|
||||
return object;
|
||||
}
|
||||
|
||||
reduceStaticPropertyName(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceSuper(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceSwitchCase(node, { test, consequent }) {
|
||||
return this.append(test, ...consequent);
|
||||
}
|
||||
|
||||
reduceSwitchDefault(node, { consequent }) {
|
||||
return this.append(...consequent);
|
||||
}
|
||||
|
||||
reduceSwitchStatement(node, { discriminant, cases }) {
|
||||
return this.append(discriminant, ...cases);
|
||||
}
|
||||
|
||||
reduceSwitchStatementWithDefault(node, { discriminant, preDefaultCases, defaultCase, postDefaultCases }) {
|
||||
return this.append(discriminant, ...preDefaultCases, defaultCase, ...postDefaultCases);
|
||||
}
|
||||
|
||||
reduceTemplateElement(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceTemplateExpression(node, { tag, elements }) {
|
||||
return this.append(tag == null ? this.identity : tag, ...elements);
|
||||
}
|
||||
|
||||
reduceThisExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceThrowStatement(node, { expression }) {
|
||||
return expression;
|
||||
}
|
||||
|
||||
reduceTryCatchStatement(node, { body, catchClause }) {
|
||||
return this.append(body, catchClause);
|
||||
}
|
||||
|
||||
reduceTryFinallyStatement(node, { body, catchClause, finalizer }) {
|
||||
return this.append(body, catchClause == null ? this.identity : catchClause, finalizer);
|
||||
}
|
||||
|
||||
reduceUnaryExpression(node, { operand }) {
|
||||
return operand;
|
||||
}
|
||||
|
||||
reduceUpdateExpression(node, { operand }) {
|
||||
return operand;
|
||||
}
|
||||
|
||||
reduceVariableDeclaration(node, { declarators }) {
|
||||
return this.append(...declarators);
|
||||
}
|
||||
|
||||
reduceVariableDeclarationStatement(node, { declaration }) {
|
||||
return declaration;
|
||||
}
|
||||
|
||||
reduceVariableDeclarator(node, { binding, init }) {
|
||||
return this.append(binding, init == null ? this.identity : init);
|
||||
}
|
||||
|
||||
reduceWhileStatement(node, { test, body }) {
|
||||
return this.append(test, body);
|
||||
}
|
||||
|
||||
reduceWithStatement(node, { object, body }) {
|
||||
return this.append(object, body);
|
||||
}
|
||||
|
||||
reduceYieldExpression(node, { expression }) {
|
||||
return expression == null ? this.identity : expression;
|
||||
}
|
||||
|
||||
reduceYieldGeneratorExpression(node, { expression }) {
|
||||
return expression;
|
||||
}
|
||||
}
|
||||
91
docs/dist/shift-reducer/reducers.js
vendored
91
docs/dist/shift-reducer/reducers.js
vendored
@ -1,91 +0,0 @@
|
||||
/*
|
||||
* Copyright 2018 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
import MonoidalReducer from './monoidal-reducer.js';
|
||||
import ThunkedMonoidalReducer from './thunked-monoidal-reducer.js';
|
||||
|
||||
const PlusMonoid = {
|
||||
empty: () => 0,
|
||||
concat: (a, b) => a + b,
|
||||
};
|
||||
|
||||
const ConcatMonoid = {
|
||||
empty: () => [],
|
||||
concat: (a, b) => a.concat(b),
|
||||
};
|
||||
|
||||
const AndMonoid = {
|
||||
empty: () => true,
|
||||
concat: (a, b) => a && b,
|
||||
concatThunk: (a, b) => a && b(),
|
||||
};
|
||||
|
||||
const OrMonoid = {
|
||||
empty: () => false,
|
||||
concat: (a, b) => a || b,
|
||||
concatThunk: (a, b) => a || b(),
|
||||
};
|
||||
|
||||
|
||||
export class PlusReducer extends MonoidalReducer {
|
||||
constructor() {
|
||||
super(PlusMonoid);
|
||||
}
|
||||
}
|
||||
|
||||
export class ThunkedPlusReducer extends ThunkedMonoidalReducer {
|
||||
constructor() {
|
||||
super(PlusMonoid);
|
||||
}
|
||||
}
|
||||
|
||||
export class ConcatReducer extends MonoidalReducer {
|
||||
constructor() {
|
||||
super(ConcatMonoid);
|
||||
}
|
||||
}
|
||||
|
||||
export class ThunkedConcatReducer extends ThunkedMonoidalReducer {
|
||||
constructor() {
|
||||
super(ConcatMonoid);
|
||||
}
|
||||
}
|
||||
|
||||
export class AndReducer extends MonoidalReducer {
|
||||
constructor() {
|
||||
super(AndMonoid);
|
||||
}
|
||||
}
|
||||
|
||||
export class ThunkedAndReducer extends ThunkedMonoidalReducer {
|
||||
constructor() {
|
||||
super(AndMonoid);
|
||||
}
|
||||
}
|
||||
|
||||
export class OrReducer extends MonoidalReducer {
|
||||
constructor() {
|
||||
super(OrMonoid);
|
||||
}
|
||||
}
|
||||
|
||||
export class ThunkedOrReducer extends ThunkedMonoidalReducer {
|
||||
constructor() {
|
||||
super(OrMonoid);
|
||||
}
|
||||
}
|
||||
418
docs/dist/shift-reducer/thunked-director.js
vendored
418
docs/dist/shift-reducer/thunked-director.js
vendored
@ -1,418 +0,0 @@
|
||||
// Generated by generate-director.js
|
||||
/**
|
||||
* Copyright 2018 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
const director = {
|
||||
ArrayAssignmentTarget(reducer, node) {
|
||||
return reducer.reduceArrayAssignmentTarget(node, { elements: node.elements.map(v => v && (() => this[v.type](reducer, v))), rest: node.rest && (() => this[node.rest.type](reducer, node.rest)) });
|
||||
},
|
||||
|
||||
ArrayBinding(reducer, node) {
|
||||
return reducer.reduceArrayBinding(node, { elements: node.elements.map(v => v && (() => this[v.type](reducer, v))), rest: node.rest && (() => this[node.rest.type](reducer, node.rest)) });
|
||||
},
|
||||
|
||||
ArrayExpression(reducer, node) {
|
||||
return reducer.reduceArrayExpression(node, { elements: node.elements.map(v => v && (() => this[v.type](reducer, v))) });
|
||||
},
|
||||
|
||||
ArrowExpression(reducer, node) {
|
||||
return reducer.reduceArrowExpression(node, { params: (() => this.FormalParameters(reducer, node.params)), body: (() => this[node.body.type](reducer, node.body)) });
|
||||
},
|
||||
|
||||
AssignmentExpression(reducer, node) {
|
||||
return reducer.reduceAssignmentExpression(node, { binding: (() => this[node.binding.type](reducer, node.binding)), expression: (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
|
||||
AssignmentTargetIdentifier(reducer, node) {
|
||||
return reducer.reduceAssignmentTargetIdentifier(node);
|
||||
},
|
||||
|
||||
AssignmentTargetPropertyIdentifier(reducer, node) {
|
||||
return reducer.reduceAssignmentTargetPropertyIdentifier(node, { binding: (() => this.AssignmentTargetIdentifier(reducer, node.binding)), init: node.init && (() => this[node.init.type](reducer, node.init)) });
|
||||
},
|
||||
|
||||
AssignmentTargetPropertyProperty(reducer, node) {
|
||||
return reducer.reduceAssignmentTargetPropertyProperty(node, { name: (() => this[node.name.type](reducer, node.name)), binding: (() => this[node.binding.type](reducer, node.binding)) });
|
||||
},
|
||||
|
||||
AssignmentTargetWithDefault(reducer, node) {
|
||||
return reducer.reduceAssignmentTargetWithDefault(node, { binding: (() => this[node.binding.type](reducer, node.binding)), init: (() => this[node.init.type](reducer, node.init)) });
|
||||
},
|
||||
|
||||
AwaitExpression(reducer, node) {
|
||||
return reducer.reduceAwaitExpression(node, { expression: (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
|
||||
BinaryExpression(reducer, node) {
|
||||
return reducer.reduceBinaryExpression(node, { left: (() => this[node.left.type](reducer, node.left)), right: (() => this[node.right.type](reducer, node.right)) });
|
||||
},
|
||||
|
||||
BindingIdentifier(reducer, node) {
|
||||
return reducer.reduceBindingIdentifier(node);
|
||||
},
|
||||
|
||||
BindingPropertyIdentifier(reducer, node) {
|
||||
return reducer.reduceBindingPropertyIdentifier(node, { binding: (() => this.BindingIdentifier(reducer, node.binding)), init: node.init && (() => this[node.init.type](reducer, node.init)) });
|
||||
},
|
||||
|
||||
BindingPropertyProperty(reducer, node) {
|
||||
return reducer.reduceBindingPropertyProperty(node, { name: (() => this[node.name.type](reducer, node.name)), binding: (() => this[node.binding.type](reducer, node.binding)) });
|
||||
},
|
||||
|
||||
BindingWithDefault(reducer, node) {
|
||||
return reducer.reduceBindingWithDefault(node, { binding: (() => this[node.binding.type](reducer, node.binding)), init: (() => this[node.init.type](reducer, node.init)) });
|
||||
},
|
||||
|
||||
Block(reducer, node) {
|
||||
return reducer.reduceBlock(node, { statements: node.statements.map(v => (() => this[v.type](reducer, v))) });
|
||||
},
|
||||
|
||||
BlockStatement(reducer, node) {
|
||||
return reducer.reduceBlockStatement(node, { block: (() => this.Block(reducer, node.block)) });
|
||||
},
|
||||
|
||||
BreakStatement(reducer, node) {
|
||||
return reducer.reduceBreakStatement(node);
|
||||
},
|
||||
|
||||
CallExpression(reducer, node) {
|
||||
return reducer.reduceCallExpression(node, { callee: (() => this[node.callee.type](reducer, node.callee)), arguments: node.arguments.map(v => (() => this[v.type](reducer, v))) });
|
||||
},
|
||||
|
||||
CatchClause(reducer, node) {
|
||||
return reducer.reduceCatchClause(node, { binding: (() => this[node.binding.type](reducer, node.binding)), body: (() => this.Block(reducer, node.body)) });
|
||||
},
|
||||
|
||||
ClassDeclaration(reducer, node) {
|
||||
return reducer.reduceClassDeclaration(node, { name: (() => this.BindingIdentifier(reducer, node.name)), super: node.super && (() => this[node.super.type](reducer, node.super)), elements: node.elements.map(v => (() => this.ClassElement(reducer, v))) });
|
||||
},
|
||||
|
||||
ClassElement(reducer, node) {
|
||||
return reducer.reduceClassElement(node, { method: (() => this[node.method.type](reducer, node.method)) });
|
||||
},
|
||||
|
||||
ClassExpression(reducer, node) {
|
||||
return reducer.reduceClassExpression(node, { name: node.name && (() => this.BindingIdentifier(reducer, node.name)), super: node.super && (() => this[node.super.type](reducer, node.super)), elements: node.elements.map(v => (() => this.ClassElement(reducer, v))) });
|
||||
},
|
||||
|
||||
CompoundAssignmentExpression(reducer, node) {
|
||||
return reducer.reduceCompoundAssignmentExpression(node, { binding: (() => this[node.binding.type](reducer, node.binding)), expression: (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
|
||||
ComputedMemberAssignmentTarget(reducer, node) {
|
||||
return reducer.reduceComputedMemberAssignmentTarget(node, { object: (() => this[node.object.type](reducer, node.object)), expression: (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
|
||||
ComputedMemberExpression(reducer, node) {
|
||||
return reducer.reduceComputedMemberExpression(node, { object: (() => this[node.object.type](reducer, node.object)), expression: (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
|
||||
ComputedPropertyName(reducer, node) {
|
||||
return reducer.reduceComputedPropertyName(node, { expression: (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
|
||||
ConditionalExpression(reducer, node) {
|
||||
return reducer.reduceConditionalExpression(node, { test: (() => this[node.test.type](reducer, node.test)), consequent: (() => this[node.consequent.type](reducer, node.consequent)), alternate: (() => this[node.alternate.type](reducer, node.alternate)) });
|
||||
},
|
||||
|
||||
ContinueStatement(reducer, node) {
|
||||
return reducer.reduceContinueStatement(node);
|
||||
},
|
||||
|
||||
DataProperty(reducer, node) {
|
||||
return reducer.reduceDataProperty(node, { name: (() => this[node.name.type](reducer, node.name)), expression: (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
|
||||
DebuggerStatement(reducer, node) {
|
||||
return reducer.reduceDebuggerStatement(node);
|
||||
},
|
||||
|
||||
Directive(reducer, node) {
|
||||
return reducer.reduceDirective(node);
|
||||
},
|
||||
|
||||
DoWhileStatement(reducer, node) {
|
||||
return reducer.reduceDoWhileStatement(node, { body: (() => this[node.body.type](reducer, node.body)), test: (() => this[node.test.type](reducer, node.test)) });
|
||||
},
|
||||
|
||||
EmptyStatement(reducer, node) {
|
||||
return reducer.reduceEmptyStatement(node);
|
||||
},
|
||||
|
||||
Export(reducer, node) {
|
||||
return reducer.reduceExport(node, { declaration: (() => this[node.declaration.type](reducer, node.declaration)) });
|
||||
},
|
||||
|
||||
ExportAllFrom(reducer, node) {
|
||||
return reducer.reduceExportAllFrom(node);
|
||||
},
|
||||
|
||||
ExportDefault(reducer, node) {
|
||||
return reducer.reduceExportDefault(node, { body: (() => this[node.body.type](reducer, node.body)) });
|
||||
},
|
||||
|
||||
ExportFrom(reducer, node) {
|
||||
return reducer.reduceExportFrom(node, { namedExports: node.namedExports.map(v => (() => this.ExportFromSpecifier(reducer, v))) });
|
||||
},
|
||||
|
||||
ExportFromSpecifier(reducer, node) {
|
||||
return reducer.reduceExportFromSpecifier(node);
|
||||
},
|
||||
|
||||
ExportLocalSpecifier(reducer, node) {
|
||||
return reducer.reduceExportLocalSpecifier(node, { name: (() => this.IdentifierExpression(reducer, node.name)) });
|
||||
},
|
||||
|
||||
ExportLocals(reducer, node) {
|
||||
return reducer.reduceExportLocals(node, { namedExports: node.namedExports.map(v => (() => this.ExportLocalSpecifier(reducer, v))) });
|
||||
},
|
||||
|
||||
ExpressionStatement(reducer, node) {
|
||||
return reducer.reduceExpressionStatement(node, { expression: (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
|
||||
ForAwaitStatement(reducer, node) {
|
||||
return reducer.reduceForAwaitStatement(node, { left: (() => this[node.left.type](reducer, node.left)), right: (() => this[node.right.type](reducer, node.right)), body: (() => this[node.body.type](reducer, node.body)) });
|
||||
},
|
||||
|
||||
ForInStatement(reducer, node) {
|
||||
return reducer.reduceForInStatement(node, { left: (() => this[node.left.type](reducer, node.left)), right: (() => this[node.right.type](reducer, node.right)), body: (() => this[node.body.type](reducer, node.body)) });
|
||||
},
|
||||
|
||||
ForOfStatement(reducer, node) {
|
||||
return reducer.reduceForOfStatement(node, { left: (() => this[node.left.type](reducer, node.left)), right: (() => this[node.right.type](reducer, node.right)), body: (() => this[node.body.type](reducer, node.body)) });
|
||||
},
|
||||
|
||||
ForStatement(reducer, node) {
|
||||
return reducer.reduceForStatement(node, { init: node.init && (() => this[node.init.type](reducer, node.init)), test: node.test && (() => this[node.test.type](reducer, node.test)), update: node.update && (() => this[node.update.type](reducer, node.update)), body: (() => this[node.body.type](reducer, node.body)) });
|
||||
},
|
||||
|
||||
FormalParameters(reducer, node) {
|
||||
return reducer.reduceFormalParameters(node, { items: node.items.map(v => (() => this[v.type](reducer, v))), rest: node.rest && (() => this[node.rest.type](reducer, node.rest)) });
|
||||
},
|
||||
|
||||
FunctionBody(reducer, node) {
|
||||
return reducer.reduceFunctionBody(node, { directives: node.directives.map(v => (() => this.Directive(reducer, v))), statements: node.statements.map(v => (() => this[v.type](reducer, v))) });
|
||||
},
|
||||
|
||||
FunctionDeclaration(reducer, node) {
|
||||
return reducer.reduceFunctionDeclaration(node, { name: (() => this.BindingIdentifier(reducer, node.name)), params: (() => this.FormalParameters(reducer, node.params)), body: (() => this.FunctionBody(reducer, node.body)) });
|
||||
},
|
||||
|
||||
FunctionExpression(reducer, node) {
|
||||
return reducer.reduceFunctionExpression(node, { name: node.name && (() => this.BindingIdentifier(reducer, node.name)), params: (() => this.FormalParameters(reducer, node.params)), body: (() => this.FunctionBody(reducer, node.body)) });
|
||||
},
|
||||
|
||||
Getter(reducer, node) {
|
||||
return reducer.reduceGetter(node, { name: (() => this[node.name.type](reducer, node.name)), body: (() => this.FunctionBody(reducer, node.body)) });
|
||||
},
|
||||
|
||||
IdentifierExpression(reducer, node) {
|
||||
return reducer.reduceIdentifierExpression(node);
|
||||
},
|
||||
|
||||
IfStatement(reducer, node) {
|
||||
return reducer.reduceIfStatement(node, { test: (() => this[node.test.type](reducer, node.test)), consequent: (() => this[node.consequent.type](reducer, node.consequent)), alternate: node.alternate && (() => this[node.alternate.type](reducer, node.alternate)) });
|
||||
},
|
||||
|
||||
Import(reducer, node) {
|
||||
return reducer.reduceImport(node, { defaultBinding: node.defaultBinding && (() => this.BindingIdentifier(reducer, node.defaultBinding)), namedImports: node.namedImports.map(v => (() => this.ImportSpecifier(reducer, v))) });
|
||||
},
|
||||
|
||||
ImportNamespace(reducer, node) {
|
||||
return reducer.reduceImportNamespace(node, { defaultBinding: node.defaultBinding && (() => this.BindingIdentifier(reducer, node.defaultBinding)), namespaceBinding: (() => this.BindingIdentifier(reducer, node.namespaceBinding)) });
|
||||
},
|
||||
|
||||
ImportSpecifier(reducer, node) {
|
||||
return reducer.reduceImportSpecifier(node, { binding: (() => this.BindingIdentifier(reducer, node.binding)) });
|
||||
},
|
||||
|
||||
LabeledStatement(reducer, node) {
|
||||
return reducer.reduceLabeledStatement(node, { body: (() => this[node.body.type](reducer, node.body)) });
|
||||
},
|
||||
|
||||
LiteralBooleanExpression(reducer, node) {
|
||||
return reducer.reduceLiteralBooleanExpression(node);
|
||||
},
|
||||
|
||||
LiteralInfinityExpression(reducer, node) {
|
||||
return reducer.reduceLiteralInfinityExpression(node);
|
||||
},
|
||||
|
||||
LiteralNullExpression(reducer, node) {
|
||||
return reducer.reduceLiteralNullExpression(node);
|
||||
},
|
||||
|
||||
LiteralNumericExpression(reducer, node) {
|
||||
return reducer.reduceLiteralNumericExpression(node);
|
||||
},
|
||||
|
||||
LiteralRegExpExpression(reducer, node) {
|
||||
return reducer.reduceLiteralRegExpExpression(node);
|
||||
},
|
||||
|
||||
LiteralStringExpression(reducer, node) {
|
||||
return reducer.reduceLiteralStringExpression(node);
|
||||
},
|
||||
|
||||
Method(reducer, node) {
|
||||
return reducer.reduceMethod(node, { name: (() => this[node.name.type](reducer, node.name)), params: (() => this.FormalParameters(reducer, node.params)), body: (() => this.FunctionBody(reducer, node.body)) });
|
||||
},
|
||||
|
||||
Module(reducer, node) {
|
||||
return reducer.reduceModule(node, { directives: node.directives.map(v => (() => this.Directive(reducer, v))), items: node.items.map(v => (() => this[v.type](reducer, v))) });
|
||||
},
|
||||
|
||||
NewExpression(reducer, node) {
|
||||
return reducer.reduceNewExpression(node, { callee: (() => this[node.callee.type](reducer, node.callee)), arguments: node.arguments.map(v => (() => this[v.type](reducer, v))) });
|
||||
},
|
||||
|
||||
NewTargetExpression(reducer, node) {
|
||||
return reducer.reduceNewTargetExpression(node);
|
||||
},
|
||||
|
||||
ObjectAssignmentTarget(reducer, node) {
|
||||
return reducer.reduceObjectAssignmentTarget(node, { properties: node.properties.map(v => (() => this[v.type](reducer, v))), rest: node.rest && (() => this[node.rest.type](reducer, node.rest)) });
|
||||
},
|
||||
|
||||
ObjectBinding(reducer, node) {
|
||||
return reducer.reduceObjectBinding(node, { properties: node.properties.map(v => (() => this[v.type](reducer, v))), rest: node.rest && (() => this[node.rest.type](reducer, node.rest)) });
|
||||
},
|
||||
|
||||
ObjectExpression(reducer, node) {
|
||||
return reducer.reduceObjectExpression(node, { properties: node.properties.map(v => (() => this[v.type](reducer, v))) });
|
||||
},
|
||||
|
||||
ReturnStatement(reducer, node) {
|
||||
return reducer.reduceReturnStatement(node, { expression: node.expression && (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
|
||||
Script(reducer, node) {
|
||||
return reducer.reduceScript(node, { directives: node.directives.map(v => (() => this.Directive(reducer, v))), statements: node.statements.map(v => (() => this[v.type](reducer, v))) });
|
||||
},
|
||||
|
||||
Setter(reducer, node) {
|
||||
return reducer.reduceSetter(node, { name: (() => this[node.name.type](reducer, node.name)), param: (() => this[node.param.type](reducer, node.param)), body: (() => this.FunctionBody(reducer, node.body)) });
|
||||
},
|
||||
|
||||
ShorthandProperty(reducer, node) {
|
||||
return reducer.reduceShorthandProperty(node, { name: (() => this.IdentifierExpression(reducer, node.name)) });
|
||||
},
|
||||
|
||||
SpreadElement(reducer, node) {
|
||||
return reducer.reduceSpreadElement(node, { expression: (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
|
||||
SpreadProperty(reducer, node) {
|
||||
return reducer.reduceSpreadProperty(node, { expression: (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
|
||||
StaticMemberAssignmentTarget(reducer, node) {
|
||||
return reducer.reduceStaticMemberAssignmentTarget(node, { object: (() => this[node.object.type](reducer, node.object)) });
|
||||
},
|
||||
|
||||
StaticMemberExpression(reducer, node) {
|
||||
return reducer.reduceStaticMemberExpression(node, { object: (() => this[node.object.type](reducer, node.object)) });
|
||||
},
|
||||
|
||||
StaticPropertyName(reducer, node) {
|
||||
return reducer.reduceStaticPropertyName(node);
|
||||
},
|
||||
|
||||
Super(reducer, node) {
|
||||
return reducer.reduceSuper(node);
|
||||
},
|
||||
|
||||
SwitchCase(reducer, node) {
|
||||
return reducer.reduceSwitchCase(node, { test: (() => this[node.test.type](reducer, node.test)), consequent: node.consequent.map(v => (() => this[v.type](reducer, v))) });
|
||||
},
|
||||
|
||||
SwitchDefault(reducer, node) {
|
||||
return reducer.reduceSwitchDefault(node, { consequent: node.consequent.map(v => (() => this[v.type](reducer, v))) });
|
||||
},
|
||||
|
||||
SwitchStatement(reducer, node) {
|
||||
return reducer.reduceSwitchStatement(node, { discriminant: (() => this[node.discriminant.type](reducer, node.discriminant)), cases: node.cases.map(v => (() => this.SwitchCase(reducer, v))) });
|
||||
},
|
||||
|
||||
SwitchStatementWithDefault(reducer, node) {
|
||||
return reducer.reduceSwitchStatementWithDefault(node, { discriminant: (() => this[node.discriminant.type](reducer, node.discriminant)), preDefaultCases: node.preDefaultCases.map(v => (() => this.SwitchCase(reducer, v))), defaultCase: (() => this.SwitchDefault(reducer, node.defaultCase)), postDefaultCases: node.postDefaultCases.map(v => (() => this.SwitchCase(reducer, v))) });
|
||||
},
|
||||
|
||||
TemplateElement(reducer, node) {
|
||||
return reducer.reduceTemplateElement(node);
|
||||
},
|
||||
|
||||
TemplateExpression(reducer, node) {
|
||||
return reducer.reduceTemplateExpression(node, { tag: node.tag && (() => this[node.tag.type](reducer, node.tag)), elements: node.elements.map(v => (() => this[v.type](reducer, v))) });
|
||||
},
|
||||
|
||||
ThisExpression(reducer, node) {
|
||||
return reducer.reduceThisExpression(node);
|
||||
},
|
||||
|
||||
ThrowStatement(reducer, node) {
|
||||
return reducer.reduceThrowStatement(node, { expression: (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
|
||||
TryCatchStatement(reducer, node) {
|
||||
return reducer.reduceTryCatchStatement(node, { body: (() => this.Block(reducer, node.body)), catchClause: (() => this.CatchClause(reducer, node.catchClause)) });
|
||||
},
|
||||
|
||||
TryFinallyStatement(reducer, node) {
|
||||
return reducer.reduceTryFinallyStatement(node, { body: (() => this.Block(reducer, node.body)), catchClause: node.catchClause && (() => this.CatchClause(reducer, node.catchClause)), finalizer: (() => this.Block(reducer, node.finalizer)) });
|
||||
},
|
||||
|
||||
UnaryExpression(reducer, node) {
|
||||
return reducer.reduceUnaryExpression(node, { operand: (() => this[node.operand.type](reducer, node.operand)) });
|
||||
},
|
||||
|
||||
UpdateExpression(reducer, node) {
|
||||
return reducer.reduceUpdateExpression(node, { operand: (() => this[node.operand.type](reducer, node.operand)) });
|
||||
},
|
||||
|
||||
VariableDeclaration(reducer, node) {
|
||||
return reducer.reduceVariableDeclaration(node, { declarators: node.declarators.map(v => (() => this.VariableDeclarator(reducer, v))) });
|
||||
},
|
||||
|
||||
VariableDeclarationStatement(reducer, node) {
|
||||
return reducer.reduceVariableDeclarationStatement(node, { declaration: (() => this.VariableDeclaration(reducer, node.declaration)) });
|
||||
},
|
||||
|
||||
VariableDeclarator(reducer, node) {
|
||||
return reducer.reduceVariableDeclarator(node, { binding: (() => this[node.binding.type](reducer, node.binding)), init: node.init && (() => this[node.init.type](reducer, node.init)) });
|
||||
},
|
||||
|
||||
WhileStatement(reducer, node) {
|
||||
return reducer.reduceWhileStatement(node, { test: (() => this[node.test.type](reducer, node.test)), body: (() => this[node.body.type](reducer, node.body)) });
|
||||
},
|
||||
|
||||
WithStatement(reducer, node) {
|
||||
return reducer.reduceWithStatement(node, { object: (() => this[node.object.type](reducer, node.object)), body: (() => this[node.body.type](reducer, node.body)) });
|
||||
},
|
||||
|
||||
YieldExpression(reducer, node) {
|
||||
return reducer.reduceYieldExpression(node, { expression: node.expression && (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
|
||||
YieldGeneratorExpression(reducer, node) {
|
||||
return reducer.reduceYieldGeneratorExpression(node, { expression: (() => this[node.expression.type](reducer, node.expression)) });
|
||||
},
|
||||
};
|
||||
|
||||
export function thunkedReduce(reducer, node) {
|
||||
return director[node.type](reducer, node);
|
||||
}
|
||||
444
docs/dist/shift-reducer/thunked-monoidal-reducer.js
vendored
444
docs/dist/shift-reducer/thunked-monoidal-reducer.js
vendored
@ -1,444 +0,0 @@
|
||||
// Generated by generate-monoidal-reducer.js
|
||||
/**
|
||||
* Copyright 2018 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import Shift from '../../_snowpack/pkg/shift-ast.js';
|
||||
|
||||
export default class MonoidalReducer {
|
||||
constructor(monoid) {
|
||||
let identity = monoid.empty();
|
||||
this.identity = identity;
|
||||
|
||||
let concatThunk;
|
||||
if (monoid.prototype && typeof monoid.prototype.concatThunk === 'function') {
|
||||
concatThunk = Function.prototype.call.bind(monoid.prototype.concatThunk);
|
||||
} else if (typeof monoid.concatThunk === 'function') {
|
||||
concatThunk = monoid.concatThunk;
|
||||
} else {
|
||||
let concat;
|
||||
if (monoid.prototype && typeof monoid.prototype.concat === 'function') {
|
||||
concat = Function.prototype.call.bind(monoid.prototype.concat);
|
||||
} else if (typeof monoid.concat === 'function') {
|
||||
concat = monoid.concat;
|
||||
} else {
|
||||
throw new TypeError('Monoid must provide a `concatThunk` or `concat` method');
|
||||
}
|
||||
if (typeof monoid.isAbsorbing === 'function') {
|
||||
let isAbsorbing = monoid.isAbsorbing;
|
||||
concatThunk = (a, b) => isAbsorbing(a) ? a : concat(a, b());
|
||||
} else {
|
||||
concatThunk = (a, b) => concat(a, b());
|
||||
}
|
||||
}
|
||||
this.append = (...args) => args.reduce(concatThunk, identity);
|
||||
}
|
||||
|
||||
reduceArrayAssignmentTarget(node, { elements, rest }) {
|
||||
return this.append(...elements.filter(n => n != null), rest == null ? () => this.identity : rest);
|
||||
}
|
||||
|
||||
reduceArrayBinding(node, { elements, rest }) {
|
||||
return this.append(...elements.filter(n => n != null), rest == null ? () => this.identity : rest);
|
||||
}
|
||||
|
||||
reduceArrayExpression(node, { elements }) {
|
||||
return this.append(...elements.filter(n => n != null));
|
||||
}
|
||||
|
||||
reduceArrowExpression(node, { params, body }) {
|
||||
return this.append(params, body);
|
||||
}
|
||||
|
||||
reduceAssignmentExpression(node, { binding, expression }) {
|
||||
return this.append(binding, expression);
|
||||
}
|
||||
|
||||
reduceAssignmentTargetIdentifier(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceAssignmentTargetPropertyIdentifier(node, { binding, init }) {
|
||||
return this.append(binding, init == null ? () => this.identity : init);
|
||||
}
|
||||
|
||||
reduceAssignmentTargetPropertyProperty(node, { name, binding }) {
|
||||
return this.append(name, binding);
|
||||
}
|
||||
|
||||
reduceAssignmentTargetWithDefault(node, { binding, init }) {
|
||||
return this.append(binding, init);
|
||||
}
|
||||
|
||||
reduceAwaitExpression(node, { expression }) {
|
||||
return expression();
|
||||
}
|
||||
|
||||
reduceBinaryExpression(node, { left, right }) {
|
||||
return this.append(left, right);
|
||||
}
|
||||
|
||||
reduceBindingIdentifier(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceBindingPropertyIdentifier(node, { binding, init }) {
|
||||
return this.append(binding, init == null ? () => this.identity : init);
|
||||
}
|
||||
|
||||
reduceBindingPropertyProperty(node, { name, binding }) {
|
||||
return this.append(name, binding);
|
||||
}
|
||||
|
||||
reduceBindingWithDefault(node, { binding, init }) {
|
||||
return this.append(binding, init);
|
||||
}
|
||||
|
||||
reduceBlock(node, { statements }) {
|
||||
return this.append(...statements);
|
||||
}
|
||||
|
||||
reduceBlockStatement(node, { block }) {
|
||||
return block();
|
||||
}
|
||||
|
||||
reduceBreakStatement(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceCallExpression(node, { callee, arguments: _arguments }) {
|
||||
return this.append(callee, ..._arguments);
|
||||
}
|
||||
|
||||
reduceCatchClause(node, { binding, body }) {
|
||||
return this.append(binding, body);
|
||||
}
|
||||
|
||||
reduceClassDeclaration(node, { name, super: _super, elements }) {
|
||||
return this.append(name, _super == null ? () => this.identity : _super, ...elements);
|
||||
}
|
||||
|
||||
reduceClassElement(node, { method }) {
|
||||
return method();
|
||||
}
|
||||
|
||||
reduceClassExpression(node, { name, super: _super, elements }) {
|
||||
return this.append(name == null ? () => this.identity : name, _super == null ? () => this.identity : _super, ...elements);
|
||||
}
|
||||
|
||||
reduceCompoundAssignmentExpression(node, { binding, expression }) {
|
||||
return this.append(binding, expression);
|
||||
}
|
||||
|
||||
reduceComputedMemberAssignmentTarget(node, { object, expression }) {
|
||||
return this.append(object, expression);
|
||||
}
|
||||
|
||||
reduceComputedMemberExpression(node, { object, expression }) {
|
||||
return this.append(object, expression);
|
||||
}
|
||||
|
||||
reduceComputedPropertyName(node, { expression }) {
|
||||
return expression();
|
||||
}
|
||||
|
||||
reduceConditionalExpression(node, { test, consequent, alternate }) {
|
||||
return this.append(test, consequent, alternate);
|
||||
}
|
||||
|
||||
reduceContinueStatement(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceDataProperty(node, { name, expression }) {
|
||||
return this.append(name, expression);
|
||||
}
|
||||
|
||||
reduceDebuggerStatement(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceDirective(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceDoWhileStatement(node, { body, test }) {
|
||||
return this.append(body, test);
|
||||
}
|
||||
|
||||
reduceEmptyStatement(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceExport(node, { declaration }) {
|
||||
return declaration();
|
||||
}
|
||||
|
||||
reduceExportAllFrom(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceExportDefault(node, { body }) {
|
||||
return body();
|
||||
}
|
||||
|
||||
reduceExportFrom(node, { namedExports }) {
|
||||
return this.append(...namedExports);
|
||||
}
|
||||
|
||||
reduceExportFromSpecifier(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceExportLocalSpecifier(node, { name }) {
|
||||
return name();
|
||||
}
|
||||
|
||||
reduceExportLocals(node, { namedExports }) {
|
||||
return this.append(...namedExports);
|
||||
}
|
||||
|
||||
reduceExpressionStatement(node, { expression }) {
|
||||
return expression();
|
||||
}
|
||||
|
||||
reduceForAwaitStatement(node, { left, right, body }) {
|
||||
return this.append(left, right, body);
|
||||
}
|
||||
|
||||
reduceForInStatement(node, { left, right, body }) {
|
||||
return this.append(left, right, body);
|
||||
}
|
||||
|
||||
reduceForOfStatement(node, { left, right, body }) {
|
||||
return this.append(left, right, body);
|
||||
}
|
||||
|
||||
reduceForStatement(node, { init, test, update, body }) {
|
||||
return this.append(init == null ? () => this.identity : init, test == null ? () => this.identity : test, update == null ? () => this.identity : update, body);
|
||||
}
|
||||
|
||||
reduceFormalParameters(node, { items, rest }) {
|
||||
return this.append(...items, rest == null ? () => this.identity : rest);
|
||||
}
|
||||
|
||||
reduceFunctionBody(node, { directives, statements }) {
|
||||
return this.append(...directives, ...statements);
|
||||
}
|
||||
|
||||
reduceFunctionDeclaration(node, { name, params, body }) {
|
||||
return this.append(name, params, body);
|
||||
}
|
||||
|
||||
reduceFunctionExpression(node, { name, params, body }) {
|
||||
return this.append(name == null ? () => this.identity : name, params, body);
|
||||
}
|
||||
|
||||
reduceGetter(node, { name, body }) {
|
||||
return this.append(name, body);
|
||||
}
|
||||
|
||||
reduceIdentifierExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceIfStatement(node, { test, consequent, alternate }) {
|
||||
return this.append(test, consequent, alternate == null ? () => this.identity : alternate);
|
||||
}
|
||||
|
||||
reduceImport(node, { defaultBinding, namedImports }) {
|
||||
return this.append(defaultBinding == null ? () => this.identity : defaultBinding, ...namedImports);
|
||||
}
|
||||
|
||||
reduceImportNamespace(node, { defaultBinding, namespaceBinding }) {
|
||||
return this.append(defaultBinding == null ? () => this.identity : defaultBinding, namespaceBinding);
|
||||
}
|
||||
|
||||
reduceImportSpecifier(node, { binding }) {
|
||||
return binding();
|
||||
}
|
||||
|
||||
reduceLabeledStatement(node, { body }) {
|
||||
return body();
|
||||
}
|
||||
|
||||
reduceLiteralBooleanExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceLiteralInfinityExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceLiteralNullExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceLiteralNumericExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceLiteralRegExpExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceLiteralStringExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceMethod(node, { name, params, body }) {
|
||||
return this.append(name, params, body);
|
||||
}
|
||||
|
||||
reduceModule(node, { directives, items }) {
|
||||
return this.append(...directives, ...items);
|
||||
}
|
||||
|
||||
reduceNewExpression(node, { callee, arguments: _arguments }) {
|
||||
return this.append(callee, ..._arguments);
|
||||
}
|
||||
|
||||
reduceNewTargetExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceObjectAssignmentTarget(node, { properties, rest }) {
|
||||
return this.append(...properties, rest == null ? () => this.identity : rest);
|
||||
}
|
||||
|
||||
reduceObjectBinding(node, { properties, rest }) {
|
||||
return this.append(...properties, rest == null ? () => this.identity : rest);
|
||||
}
|
||||
|
||||
reduceObjectExpression(node, { properties }) {
|
||||
return this.append(...properties);
|
||||
}
|
||||
|
||||
reduceReturnStatement(node, { expression }) {
|
||||
return expression == null ? this.identity : expression();
|
||||
}
|
||||
|
||||
reduceScript(node, { directives, statements }) {
|
||||
return this.append(...directives, ...statements);
|
||||
}
|
||||
|
||||
reduceSetter(node, { name, param, body }) {
|
||||
return this.append(name, param, body);
|
||||
}
|
||||
|
||||
reduceShorthandProperty(node, { name }) {
|
||||
return name();
|
||||
}
|
||||
|
||||
reduceSpreadElement(node, { expression }) {
|
||||
return expression();
|
||||
}
|
||||
|
||||
reduceSpreadProperty(node, { expression }) {
|
||||
return expression();
|
||||
}
|
||||
|
||||
reduceStaticMemberAssignmentTarget(node, { object }) {
|
||||
return object();
|
||||
}
|
||||
|
||||
reduceStaticMemberExpression(node, { object }) {
|
||||
return object();
|
||||
}
|
||||
|
||||
reduceStaticPropertyName(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceSuper(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceSwitchCase(node, { test, consequent }) {
|
||||
return this.append(test, ...consequent);
|
||||
}
|
||||
|
||||
reduceSwitchDefault(node, { consequent }) {
|
||||
return this.append(...consequent);
|
||||
}
|
||||
|
||||
reduceSwitchStatement(node, { discriminant, cases }) {
|
||||
return this.append(discriminant, ...cases);
|
||||
}
|
||||
|
||||
reduceSwitchStatementWithDefault(node, { discriminant, preDefaultCases, defaultCase, postDefaultCases }) {
|
||||
return this.append(discriminant, ...preDefaultCases, defaultCase, ...postDefaultCases);
|
||||
}
|
||||
|
||||
reduceTemplateElement(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceTemplateExpression(node, { tag, elements }) {
|
||||
return this.append(tag == null ? () => this.identity : tag, ...elements);
|
||||
}
|
||||
|
||||
reduceThisExpression(node) {
|
||||
return this.identity;
|
||||
}
|
||||
|
||||
reduceThrowStatement(node, { expression }) {
|
||||
return expression();
|
||||
}
|
||||
|
||||
reduceTryCatchStatement(node, { body, catchClause }) {
|
||||
return this.append(body, catchClause);
|
||||
}
|
||||
|
||||
reduceTryFinallyStatement(node, { body, catchClause, finalizer }) {
|
||||
return this.append(body, catchClause == null ? () => this.identity : catchClause, finalizer);
|
||||
}
|
||||
|
||||
reduceUnaryExpression(node, { operand }) {
|
||||
return operand();
|
||||
}
|
||||
|
||||
reduceUpdateExpression(node, { operand }) {
|
||||
return operand();
|
||||
}
|
||||
|
||||
reduceVariableDeclaration(node, { declarators }) {
|
||||
return this.append(...declarators);
|
||||
}
|
||||
|
||||
reduceVariableDeclarationStatement(node, { declaration }) {
|
||||
return declaration();
|
||||
}
|
||||
|
||||
reduceVariableDeclarator(node, { binding, init }) {
|
||||
return this.append(binding, init == null ? () => this.identity : init);
|
||||
}
|
||||
|
||||
reduceWhileStatement(node, { test, body }) {
|
||||
return this.append(test, body);
|
||||
}
|
||||
|
||||
reduceWithStatement(node, { object, body }) {
|
||||
return this.append(object, body);
|
||||
}
|
||||
|
||||
reduceYieldExpression(node, { expression }) {
|
||||
return expression == null ? this.identity : expression();
|
||||
}
|
||||
|
||||
reduceYieldGeneratorExpression(node, { expression }) {
|
||||
return expression();
|
||||
}
|
||||
}
|
||||
416
docs/dist/shift-reducer/thunkify-class.js
vendored
416
docs/dist/shift-reducer/thunkify-class.js
vendored
@ -1,416 +0,0 @@
|
||||
// Generated by generate-thunkify.js
|
||||
/**
|
||||
* Copyright 2018 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
export default function thunkifyClass(reducerClass) {
|
||||
return class extends reducerClass {
|
||||
reduceArrayAssignmentTarget(node, { elements, rest }) {
|
||||
return super.reduceArrayAssignmentTarget(node, { elements: elements.map(n => n == null ? null : n()), rest: rest == null ? null : rest() });
|
||||
}
|
||||
|
||||
reduceArrayBinding(node, { elements, rest }) {
|
||||
return super.reduceArrayBinding(node, { elements: elements.map(n => n == null ? null : n()), rest: rest == null ? null : rest() });
|
||||
}
|
||||
|
||||
reduceArrayExpression(node, { elements }) {
|
||||
return super.reduceArrayExpression(node, { elements: elements.map(n => n == null ? null : n()) });
|
||||
}
|
||||
|
||||
reduceArrowExpression(node, { params, body }) {
|
||||
return super.reduceArrowExpression(node, { params: params(), body: body() });
|
||||
}
|
||||
|
||||
reduceAssignmentExpression(node, { binding, expression }) {
|
||||
return super.reduceAssignmentExpression(node, { binding: binding(), expression: expression() });
|
||||
}
|
||||
|
||||
reduceAssignmentTargetIdentifier(node) {
|
||||
return super.reduceAssignmentTargetIdentifier(node);
|
||||
}
|
||||
|
||||
reduceAssignmentTargetPropertyIdentifier(node, { binding, init }) {
|
||||
return super.reduceAssignmentTargetPropertyIdentifier(node, { binding: binding(), init: init == null ? null : init() });
|
||||
}
|
||||
|
||||
reduceAssignmentTargetPropertyProperty(node, { name, binding }) {
|
||||
return super.reduceAssignmentTargetPropertyProperty(node, { name: name(), binding: binding() });
|
||||
}
|
||||
|
||||
reduceAssignmentTargetWithDefault(node, { binding, init }) {
|
||||
return super.reduceAssignmentTargetWithDefault(node, { binding: binding(), init: init() });
|
||||
}
|
||||
|
||||
reduceAwaitExpression(node, { expression }) {
|
||||
return super.reduceAwaitExpression(node, { expression: expression() });
|
||||
}
|
||||
|
||||
reduceBinaryExpression(node, { left, right }) {
|
||||
return super.reduceBinaryExpression(node, { left: left(), right: right() });
|
||||
}
|
||||
|
||||
reduceBindingIdentifier(node) {
|
||||
return super.reduceBindingIdentifier(node);
|
||||
}
|
||||
|
||||
reduceBindingPropertyIdentifier(node, { binding, init }) {
|
||||
return super.reduceBindingPropertyIdentifier(node, { binding: binding(), init: init == null ? null : init() });
|
||||
}
|
||||
|
||||
reduceBindingPropertyProperty(node, { name, binding }) {
|
||||
return super.reduceBindingPropertyProperty(node, { name: name(), binding: binding() });
|
||||
}
|
||||
|
||||
reduceBindingWithDefault(node, { binding, init }) {
|
||||
return super.reduceBindingWithDefault(node, { binding: binding(), init: init() });
|
||||
}
|
||||
|
||||
reduceBlock(node, { statements }) {
|
||||
return super.reduceBlock(node, { statements: statements.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceBlockStatement(node, { block }) {
|
||||
return super.reduceBlockStatement(node, { block: block() });
|
||||
}
|
||||
|
||||
reduceBreakStatement(node) {
|
||||
return super.reduceBreakStatement(node);
|
||||
}
|
||||
|
||||
reduceCallExpression(node, { callee, arguments: _arguments }) {
|
||||
return super.reduceCallExpression(node, { callee: callee(), arguments: _arguments.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceCatchClause(node, { binding, body }) {
|
||||
return super.reduceCatchClause(node, { binding: binding(), body: body() });
|
||||
}
|
||||
|
||||
reduceClassDeclaration(node, { name, super: _super, elements }) {
|
||||
return super.reduceClassDeclaration(node, { name: name(), super: _super == null ? null : _super(), elements: elements.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceClassElement(node, { method }) {
|
||||
return super.reduceClassElement(node, { method: method() });
|
||||
}
|
||||
|
||||
reduceClassExpression(node, { name, super: _super, elements }) {
|
||||
return super.reduceClassExpression(node, { name: name == null ? null : name(), super: _super == null ? null : _super(), elements: elements.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceCompoundAssignmentExpression(node, { binding, expression }) {
|
||||
return super.reduceCompoundAssignmentExpression(node, { binding: binding(), expression: expression() });
|
||||
}
|
||||
|
||||
reduceComputedMemberAssignmentTarget(node, { object, expression }) {
|
||||
return super.reduceComputedMemberAssignmentTarget(node, { object: object(), expression: expression() });
|
||||
}
|
||||
|
||||
reduceComputedMemberExpression(node, { object, expression }) {
|
||||
return super.reduceComputedMemberExpression(node, { object: object(), expression: expression() });
|
||||
}
|
||||
|
||||
reduceComputedPropertyName(node, { expression }) {
|
||||
return super.reduceComputedPropertyName(node, { expression: expression() });
|
||||
}
|
||||
|
||||
reduceConditionalExpression(node, { test, consequent, alternate }) {
|
||||
return super.reduceConditionalExpression(node, { test: test(), consequent: consequent(), alternate: alternate() });
|
||||
}
|
||||
|
||||
reduceContinueStatement(node) {
|
||||
return super.reduceContinueStatement(node);
|
||||
}
|
||||
|
||||
reduceDataProperty(node, { name, expression }) {
|
||||
return super.reduceDataProperty(node, { name: name(), expression: expression() });
|
||||
}
|
||||
|
||||
reduceDebuggerStatement(node) {
|
||||
return super.reduceDebuggerStatement(node);
|
||||
}
|
||||
|
||||
reduceDirective(node) {
|
||||
return super.reduceDirective(node);
|
||||
}
|
||||
|
||||
reduceDoWhileStatement(node, { body, test }) {
|
||||
return super.reduceDoWhileStatement(node, { body: body(), test: test() });
|
||||
}
|
||||
|
||||
reduceEmptyStatement(node) {
|
||||
return super.reduceEmptyStatement(node);
|
||||
}
|
||||
|
||||
reduceExport(node, { declaration }) {
|
||||
return super.reduceExport(node, { declaration: declaration() });
|
||||
}
|
||||
|
||||
reduceExportAllFrom(node) {
|
||||
return super.reduceExportAllFrom(node);
|
||||
}
|
||||
|
||||
reduceExportDefault(node, { body }) {
|
||||
return super.reduceExportDefault(node, { body: body() });
|
||||
}
|
||||
|
||||
reduceExportFrom(node, { namedExports }) {
|
||||
return super.reduceExportFrom(node, { namedExports: namedExports.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceExportFromSpecifier(node) {
|
||||
return super.reduceExportFromSpecifier(node);
|
||||
}
|
||||
|
||||
reduceExportLocalSpecifier(node, { name }) {
|
||||
return super.reduceExportLocalSpecifier(node, { name: name() });
|
||||
}
|
||||
|
||||
reduceExportLocals(node, { namedExports }) {
|
||||
return super.reduceExportLocals(node, { namedExports: namedExports.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceExpressionStatement(node, { expression }) {
|
||||
return super.reduceExpressionStatement(node, { expression: expression() });
|
||||
}
|
||||
|
||||
reduceForAwaitStatement(node, { left, right, body }) {
|
||||
return super.reduceForAwaitStatement(node, { left: left(), right: right(), body: body() });
|
||||
}
|
||||
|
||||
reduceForInStatement(node, { left, right, body }) {
|
||||
return super.reduceForInStatement(node, { left: left(), right: right(), body: body() });
|
||||
}
|
||||
|
||||
reduceForOfStatement(node, { left, right, body }) {
|
||||
return super.reduceForOfStatement(node, { left: left(), right: right(), body: body() });
|
||||
}
|
||||
|
||||
reduceForStatement(node, { init, test, update, body }) {
|
||||
return super.reduceForStatement(node, { init: init == null ? null : init(), test: test == null ? null : test(), update: update == null ? null : update(), body: body() });
|
||||
}
|
||||
|
||||
reduceFormalParameters(node, { items, rest }) {
|
||||
return super.reduceFormalParameters(node, { items: items.map(n => n()), rest: rest == null ? null : rest() });
|
||||
}
|
||||
|
||||
reduceFunctionBody(node, { directives, statements }) {
|
||||
return super.reduceFunctionBody(node, { directives: directives.map(n => n()), statements: statements.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceFunctionDeclaration(node, { name, params, body }) {
|
||||
return super.reduceFunctionDeclaration(node, { name: name(), params: params(), body: body() });
|
||||
}
|
||||
|
||||
reduceFunctionExpression(node, { name, params, body }) {
|
||||
return super.reduceFunctionExpression(node, { name: name == null ? null : name(), params: params(), body: body() });
|
||||
}
|
||||
|
||||
reduceGetter(node, { name, body }) {
|
||||
return super.reduceGetter(node, { name: name(), body: body() });
|
||||
}
|
||||
|
||||
reduceIdentifierExpression(node) {
|
||||
return super.reduceIdentifierExpression(node);
|
||||
}
|
||||
|
||||
reduceIfStatement(node, { test, consequent, alternate }) {
|
||||
return super.reduceIfStatement(node, { test: test(), consequent: consequent(), alternate: alternate == null ? null : alternate() });
|
||||
}
|
||||
|
||||
reduceImport(node, { defaultBinding, namedImports }) {
|
||||
return super.reduceImport(node, { defaultBinding: defaultBinding == null ? null : defaultBinding(), namedImports: namedImports.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceImportNamespace(node, { defaultBinding, namespaceBinding }) {
|
||||
return super.reduceImportNamespace(node, { defaultBinding: defaultBinding == null ? null : defaultBinding(), namespaceBinding: namespaceBinding() });
|
||||
}
|
||||
|
||||
reduceImportSpecifier(node, { binding }) {
|
||||
return super.reduceImportSpecifier(node, { binding: binding() });
|
||||
}
|
||||
|
||||
reduceLabeledStatement(node, { body }) {
|
||||
return super.reduceLabeledStatement(node, { body: body() });
|
||||
}
|
||||
|
||||
reduceLiteralBooleanExpression(node) {
|
||||
return super.reduceLiteralBooleanExpression(node);
|
||||
}
|
||||
|
||||
reduceLiteralInfinityExpression(node) {
|
||||
return super.reduceLiteralInfinityExpression(node);
|
||||
}
|
||||
|
||||
reduceLiteralNullExpression(node) {
|
||||
return super.reduceLiteralNullExpression(node);
|
||||
}
|
||||
|
||||
reduceLiteralNumericExpression(node) {
|
||||
return super.reduceLiteralNumericExpression(node);
|
||||
}
|
||||
|
||||
reduceLiteralRegExpExpression(node) {
|
||||
return super.reduceLiteralRegExpExpression(node);
|
||||
}
|
||||
|
||||
reduceLiteralStringExpression(node) {
|
||||
return super.reduceLiteralStringExpression(node);
|
||||
}
|
||||
|
||||
reduceMethod(node, { name, params, body }) {
|
||||
return super.reduceMethod(node, { name: name(), params: params(), body: body() });
|
||||
}
|
||||
|
||||
reduceModule(node, { directives, items }) {
|
||||
return super.reduceModule(node, { directives: directives.map(n => n()), items: items.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceNewExpression(node, { callee, arguments: _arguments }) {
|
||||
return super.reduceNewExpression(node, { callee: callee(), arguments: _arguments.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceNewTargetExpression(node) {
|
||||
return super.reduceNewTargetExpression(node);
|
||||
}
|
||||
|
||||
reduceObjectAssignmentTarget(node, { properties, rest }) {
|
||||
return super.reduceObjectAssignmentTarget(node, { properties: properties.map(n => n()), rest: rest == null ? null : rest() });
|
||||
}
|
||||
|
||||
reduceObjectBinding(node, { properties, rest }) {
|
||||
return super.reduceObjectBinding(node, { properties: properties.map(n => n()), rest: rest == null ? null : rest() });
|
||||
}
|
||||
|
||||
reduceObjectExpression(node, { properties }) {
|
||||
return super.reduceObjectExpression(node, { properties: properties.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceReturnStatement(node, { expression }) {
|
||||
return super.reduceReturnStatement(node, { expression: expression == null ? null : expression() });
|
||||
}
|
||||
|
||||
reduceScript(node, { directives, statements }) {
|
||||
return super.reduceScript(node, { directives: directives.map(n => n()), statements: statements.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceSetter(node, { name, param, body }) {
|
||||
return super.reduceSetter(node, { name: name(), param: param(), body: body() });
|
||||
}
|
||||
|
||||
reduceShorthandProperty(node, { name }) {
|
||||
return super.reduceShorthandProperty(node, { name: name() });
|
||||
}
|
||||
|
||||
reduceSpreadElement(node, { expression }) {
|
||||
return super.reduceSpreadElement(node, { expression: expression() });
|
||||
}
|
||||
|
||||
reduceSpreadProperty(node, { expression }) {
|
||||
return super.reduceSpreadProperty(node, { expression: expression() });
|
||||
}
|
||||
|
||||
reduceStaticMemberAssignmentTarget(node, { object }) {
|
||||
return super.reduceStaticMemberAssignmentTarget(node, { object: object() });
|
||||
}
|
||||
|
||||
reduceStaticMemberExpression(node, { object }) {
|
||||
return super.reduceStaticMemberExpression(node, { object: object() });
|
||||
}
|
||||
|
||||
reduceStaticPropertyName(node) {
|
||||
return super.reduceStaticPropertyName(node);
|
||||
}
|
||||
|
||||
reduceSuper(node) {
|
||||
return super.reduceSuper(node);
|
||||
}
|
||||
|
||||
reduceSwitchCase(node, { test, consequent }) {
|
||||
return super.reduceSwitchCase(node, { test: test(), consequent: consequent.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceSwitchDefault(node, { consequent }) {
|
||||
return super.reduceSwitchDefault(node, { consequent: consequent.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceSwitchStatement(node, { discriminant, cases }) {
|
||||
return super.reduceSwitchStatement(node, { discriminant: discriminant(), cases: cases.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceSwitchStatementWithDefault(node, { discriminant, preDefaultCases, defaultCase, postDefaultCases }) {
|
||||
return super.reduceSwitchStatementWithDefault(node, { discriminant: discriminant(), preDefaultCases: preDefaultCases.map(n => n()), defaultCase: defaultCase(), postDefaultCases: postDefaultCases.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceTemplateElement(node) {
|
||||
return super.reduceTemplateElement(node);
|
||||
}
|
||||
|
||||
reduceTemplateExpression(node, { tag, elements }) {
|
||||
return super.reduceTemplateExpression(node, { tag: tag == null ? null : tag(), elements: elements.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceThisExpression(node) {
|
||||
return super.reduceThisExpression(node);
|
||||
}
|
||||
|
||||
reduceThrowStatement(node, { expression }) {
|
||||
return super.reduceThrowStatement(node, { expression: expression() });
|
||||
}
|
||||
|
||||
reduceTryCatchStatement(node, { body, catchClause }) {
|
||||
return super.reduceTryCatchStatement(node, { body: body(), catchClause: catchClause() });
|
||||
}
|
||||
|
||||
reduceTryFinallyStatement(node, { body, catchClause, finalizer }) {
|
||||
return super.reduceTryFinallyStatement(node, { body: body(), catchClause: catchClause == null ? null : catchClause(), finalizer: finalizer() });
|
||||
}
|
||||
|
||||
reduceUnaryExpression(node, { operand }) {
|
||||
return super.reduceUnaryExpression(node, { operand: operand() });
|
||||
}
|
||||
|
||||
reduceUpdateExpression(node, { operand }) {
|
||||
return super.reduceUpdateExpression(node, { operand: operand() });
|
||||
}
|
||||
|
||||
reduceVariableDeclaration(node, { declarators }) {
|
||||
return super.reduceVariableDeclaration(node, { declarators: declarators.map(n => n()) });
|
||||
}
|
||||
|
||||
reduceVariableDeclarationStatement(node, { declaration }) {
|
||||
return super.reduceVariableDeclarationStatement(node, { declaration: declaration() });
|
||||
}
|
||||
|
||||
reduceVariableDeclarator(node, { binding, init }) {
|
||||
return super.reduceVariableDeclarator(node, { binding: binding(), init: init == null ? null : init() });
|
||||
}
|
||||
|
||||
reduceWhileStatement(node, { test, body }) {
|
||||
return super.reduceWhileStatement(node, { test: test(), body: body() });
|
||||
}
|
||||
|
||||
reduceWithStatement(node, { object, body }) {
|
||||
return super.reduceWithStatement(node, { object: object(), body: body() });
|
||||
}
|
||||
|
||||
reduceYieldExpression(node, { expression }) {
|
||||
return super.reduceYieldExpression(node, { expression: expression == null ? null : expression() });
|
||||
}
|
||||
|
||||
reduceYieldGeneratorExpression(node, { expression }) {
|
||||
return super.reduceYieldGeneratorExpression(node, { expression: expression() });
|
||||
}
|
||||
};
|
||||
}
|
||||
416
docs/dist/shift-reducer/thunkify.js
vendored
416
docs/dist/shift-reducer/thunkify.js
vendored
@ -1,416 +0,0 @@
|
||||
// Generated by generate-thunkify.js
|
||||
/**
|
||||
* Copyright 2018 Shape Security, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License")
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
export default function thunkify(reducer) {
|
||||
return {
|
||||
reduceArrayAssignmentTarget(node, { elements, rest }) {
|
||||
return reducer.reduceArrayAssignmentTarget(node, { elements: elements.map(n => n == null ? null : n()), rest: rest == null ? null : rest() });
|
||||
},
|
||||
|
||||
reduceArrayBinding(node, { elements, rest }) {
|
||||
return reducer.reduceArrayBinding(node, { elements: elements.map(n => n == null ? null : n()), rest: rest == null ? null : rest() });
|
||||
},
|
||||
|
||||
reduceArrayExpression(node, { elements }) {
|
||||
return reducer.reduceArrayExpression(node, { elements: elements.map(n => n == null ? null : n()) });
|
||||
},
|
||||
|
||||
reduceArrowExpression(node, { params, body }) {
|
||||
return reducer.reduceArrowExpression(node, { params: params(), body: body() });
|
||||
},
|
||||
|
||||
reduceAssignmentExpression(node, { binding, expression }) {
|
||||
return reducer.reduceAssignmentExpression(node, { binding: binding(), expression: expression() });
|
||||
},
|
||||
|
||||
reduceAssignmentTargetIdentifier(node) {
|
||||
return reducer.reduceAssignmentTargetIdentifier(node);
|
||||
},
|
||||
|
||||
reduceAssignmentTargetPropertyIdentifier(node, { binding, init }) {
|
||||
return reducer.reduceAssignmentTargetPropertyIdentifier(node, { binding: binding(), init: init == null ? null : init() });
|
||||
},
|
||||
|
||||
reduceAssignmentTargetPropertyProperty(node, { name, binding }) {
|
||||
return reducer.reduceAssignmentTargetPropertyProperty(node, { name: name(), binding: binding() });
|
||||
},
|
||||
|
||||
reduceAssignmentTargetWithDefault(node, { binding, init }) {
|
||||
return reducer.reduceAssignmentTargetWithDefault(node, { binding: binding(), init: init() });
|
||||
},
|
||||
|
||||
reduceAwaitExpression(node, { expression }) {
|
||||
return reducer.reduceAwaitExpression(node, { expression: expression() });
|
||||
},
|
||||
|
||||
reduceBinaryExpression(node, { left, right }) {
|
||||
return reducer.reduceBinaryExpression(node, { left: left(), right: right() });
|
||||
},
|
||||
|
||||
reduceBindingIdentifier(node) {
|
||||
return reducer.reduceBindingIdentifier(node);
|
||||
},
|
||||
|
||||
reduceBindingPropertyIdentifier(node, { binding, init }) {
|
||||
return reducer.reduceBindingPropertyIdentifier(node, { binding: binding(), init: init == null ? null : init() });
|
||||
},
|
||||
|
||||
reduceBindingPropertyProperty(node, { name, binding }) {
|
||||
return reducer.reduceBindingPropertyProperty(node, { name: name(), binding: binding() });
|
||||
},
|
||||
|
||||
reduceBindingWithDefault(node, { binding, init }) {
|
||||
return reducer.reduceBindingWithDefault(node, { binding: binding(), init: init() });
|
||||
},
|
||||
|
||||
reduceBlock(node, { statements }) {
|
||||
return reducer.reduceBlock(node, { statements: statements.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceBlockStatement(node, { block }) {
|
||||
return reducer.reduceBlockStatement(node, { block: block() });
|
||||
},
|
||||
|
||||
reduceBreakStatement(node) {
|
||||
return reducer.reduceBreakStatement(node);
|
||||
},
|
||||
|
||||
reduceCallExpression(node, { callee, arguments: _arguments }) {
|
||||
return reducer.reduceCallExpression(node, { callee: callee(), arguments: _arguments.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceCatchClause(node, { binding, body }) {
|
||||
return reducer.reduceCatchClause(node, { binding: binding(), body: body() });
|
||||
},
|
||||
|
||||
reduceClassDeclaration(node, { name, super: _super, elements }) {
|
||||
return reducer.reduceClassDeclaration(node, { name: name(), super: _super == null ? null : _super(), elements: elements.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceClassElement(node, { method }) {
|
||||
return reducer.reduceClassElement(node, { method: method() });
|
||||
},
|
||||
|
||||
reduceClassExpression(node, { name, super: _super, elements }) {
|
||||
return reducer.reduceClassExpression(node, { name: name == null ? null : name(), super: _super == null ? null : _super(), elements: elements.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceCompoundAssignmentExpression(node, { binding, expression }) {
|
||||
return reducer.reduceCompoundAssignmentExpression(node, { binding: binding(), expression: expression() });
|
||||
},
|
||||
|
||||
reduceComputedMemberAssignmentTarget(node, { object, expression }) {
|
||||
return reducer.reduceComputedMemberAssignmentTarget(node, { object: object(), expression: expression() });
|
||||
},
|
||||
|
||||
reduceComputedMemberExpression(node, { object, expression }) {
|
||||
return reducer.reduceComputedMemberExpression(node, { object: object(), expression: expression() });
|
||||
},
|
||||
|
||||
reduceComputedPropertyName(node, { expression }) {
|
||||
return reducer.reduceComputedPropertyName(node, { expression: expression() });
|
||||
},
|
||||
|
||||
reduceConditionalExpression(node, { test, consequent, alternate }) {
|
||||
return reducer.reduceConditionalExpression(node, { test: test(), consequent: consequent(), alternate: alternate() });
|
||||
},
|
||||
|
||||
reduceContinueStatement(node) {
|
||||
return reducer.reduceContinueStatement(node);
|
||||
},
|
||||
|
||||
reduceDataProperty(node, { name, expression }) {
|
||||
return reducer.reduceDataProperty(node, { name: name(), expression: expression() });
|
||||
},
|
||||
|
||||
reduceDebuggerStatement(node) {
|
||||
return reducer.reduceDebuggerStatement(node);
|
||||
},
|
||||
|
||||
reduceDirective(node) {
|
||||
return reducer.reduceDirective(node);
|
||||
},
|
||||
|
||||
reduceDoWhileStatement(node, { body, test }) {
|
||||
return reducer.reduceDoWhileStatement(node, { body: body(), test: test() });
|
||||
},
|
||||
|
||||
reduceEmptyStatement(node) {
|
||||
return reducer.reduceEmptyStatement(node);
|
||||
},
|
||||
|
||||
reduceExport(node, { declaration }) {
|
||||
return reducer.reduceExport(node, { declaration: declaration() });
|
||||
},
|
||||
|
||||
reduceExportAllFrom(node) {
|
||||
return reducer.reduceExportAllFrom(node);
|
||||
},
|
||||
|
||||
reduceExportDefault(node, { body }) {
|
||||
return reducer.reduceExportDefault(node, { body: body() });
|
||||
},
|
||||
|
||||
reduceExportFrom(node, { namedExports }) {
|
||||
return reducer.reduceExportFrom(node, { namedExports: namedExports.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceExportFromSpecifier(node) {
|
||||
return reducer.reduceExportFromSpecifier(node);
|
||||
},
|
||||
|
||||
reduceExportLocalSpecifier(node, { name }) {
|
||||
return reducer.reduceExportLocalSpecifier(node, { name: name() });
|
||||
},
|
||||
|
||||
reduceExportLocals(node, { namedExports }) {
|
||||
return reducer.reduceExportLocals(node, { namedExports: namedExports.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceExpressionStatement(node, { expression }) {
|
||||
return reducer.reduceExpressionStatement(node, { expression: expression() });
|
||||
},
|
||||
|
||||
reduceForAwaitStatement(node, { left, right, body }) {
|
||||
return reducer.reduceForAwaitStatement(node, { left: left(), right: right(), body: body() });
|
||||
},
|
||||
|
||||
reduceForInStatement(node, { left, right, body }) {
|
||||
return reducer.reduceForInStatement(node, { left: left(), right: right(), body: body() });
|
||||
},
|
||||
|
||||
reduceForOfStatement(node, { left, right, body }) {
|
||||
return reducer.reduceForOfStatement(node, { left: left(), right: right(), body: body() });
|
||||
},
|
||||
|
||||
reduceForStatement(node, { init, test, update, body }) {
|
||||
return reducer.reduceForStatement(node, { init: init == null ? null : init(), test: test == null ? null : test(), update: update == null ? null : update(), body: body() });
|
||||
},
|
||||
|
||||
reduceFormalParameters(node, { items, rest }) {
|
||||
return reducer.reduceFormalParameters(node, { items: items.map(n => n()), rest: rest == null ? null : rest() });
|
||||
},
|
||||
|
||||
reduceFunctionBody(node, { directives, statements }) {
|
||||
return reducer.reduceFunctionBody(node, { directives: directives.map(n => n()), statements: statements.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceFunctionDeclaration(node, { name, params, body }) {
|
||||
return reducer.reduceFunctionDeclaration(node, { name: name(), params: params(), body: body() });
|
||||
},
|
||||
|
||||
reduceFunctionExpression(node, { name, params, body }) {
|
||||
return reducer.reduceFunctionExpression(node, { name: name == null ? null : name(), params: params(), body: body() });
|
||||
},
|
||||
|
||||
reduceGetter(node, { name, body }) {
|
||||
return reducer.reduceGetter(node, { name: name(), body: body() });
|
||||
},
|
||||
|
||||
reduceIdentifierExpression(node) {
|
||||
return reducer.reduceIdentifierExpression(node);
|
||||
},
|
||||
|
||||
reduceIfStatement(node, { test, consequent, alternate }) {
|
||||
return reducer.reduceIfStatement(node, { test: test(), consequent: consequent(), alternate: alternate == null ? null : alternate() });
|
||||
},
|
||||
|
||||
reduceImport(node, { defaultBinding, namedImports }) {
|
||||
return reducer.reduceImport(node, { defaultBinding: defaultBinding == null ? null : defaultBinding(), namedImports: namedImports.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceImportNamespace(node, { defaultBinding, namespaceBinding }) {
|
||||
return reducer.reduceImportNamespace(node, { defaultBinding: defaultBinding == null ? null : defaultBinding(), namespaceBinding: namespaceBinding() });
|
||||
},
|
||||
|
||||
reduceImportSpecifier(node, { binding }) {
|
||||
return reducer.reduceImportSpecifier(node, { binding: binding() });
|
||||
},
|
||||
|
||||
reduceLabeledStatement(node, { body }) {
|
||||
return reducer.reduceLabeledStatement(node, { body: body() });
|
||||
},
|
||||
|
||||
reduceLiteralBooleanExpression(node) {
|
||||
return reducer.reduceLiteralBooleanExpression(node);
|
||||
},
|
||||
|
||||
reduceLiteralInfinityExpression(node) {
|
||||
return reducer.reduceLiteralInfinityExpression(node);
|
||||
},
|
||||
|
||||
reduceLiteralNullExpression(node) {
|
||||
return reducer.reduceLiteralNullExpression(node);
|
||||
},
|
||||
|
||||
reduceLiteralNumericExpression(node) {
|
||||
return reducer.reduceLiteralNumericExpression(node);
|
||||
},
|
||||
|
||||
reduceLiteralRegExpExpression(node) {
|
||||
return reducer.reduceLiteralRegExpExpression(node);
|
||||
},
|
||||
|
||||
reduceLiteralStringExpression(node) {
|
||||
return reducer.reduceLiteralStringExpression(node);
|
||||
},
|
||||
|
||||
reduceMethod(node, { name, params, body }) {
|
||||
return reducer.reduceMethod(node, { name: name(), params: params(), body: body() });
|
||||
},
|
||||
|
||||
reduceModule(node, { directives, items }) {
|
||||
return reducer.reduceModule(node, { directives: directives.map(n => n()), items: items.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceNewExpression(node, { callee, arguments: _arguments }) {
|
||||
return reducer.reduceNewExpression(node, { callee: callee(), arguments: _arguments.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceNewTargetExpression(node) {
|
||||
return reducer.reduceNewTargetExpression(node);
|
||||
},
|
||||
|
||||
reduceObjectAssignmentTarget(node, { properties, rest }) {
|
||||
return reducer.reduceObjectAssignmentTarget(node, { properties: properties.map(n => n()), rest: rest == null ? null : rest() });
|
||||
},
|
||||
|
||||
reduceObjectBinding(node, { properties, rest }) {
|
||||
return reducer.reduceObjectBinding(node, { properties: properties.map(n => n()), rest: rest == null ? null : rest() });
|
||||
},
|
||||
|
||||
reduceObjectExpression(node, { properties }) {
|
||||
return reducer.reduceObjectExpression(node, { properties: properties.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceReturnStatement(node, { expression }) {
|
||||
return reducer.reduceReturnStatement(node, { expression: expression == null ? null : expression() });
|
||||
},
|
||||
|
||||
reduceScript(node, { directives, statements }) {
|
||||
return reducer.reduceScript(node, { directives: directives.map(n => n()), statements: statements.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceSetter(node, { name, param, body }) {
|
||||
return reducer.reduceSetter(node, { name: name(), param: param(), body: body() });
|
||||
},
|
||||
|
||||
reduceShorthandProperty(node, { name }) {
|
||||
return reducer.reduceShorthandProperty(node, { name: name() });
|
||||
},
|
||||
|
||||
reduceSpreadElement(node, { expression }) {
|
||||
return reducer.reduceSpreadElement(node, { expression: expression() });
|
||||
},
|
||||
|
||||
reduceSpreadProperty(node, { expression }) {
|
||||
return reducer.reduceSpreadProperty(node, { expression: expression() });
|
||||
},
|
||||
|
||||
reduceStaticMemberAssignmentTarget(node, { object }) {
|
||||
return reducer.reduceStaticMemberAssignmentTarget(node, { object: object() });
|
||||
},
|
||||
|
||||
reduceStaticMemberExpression(node, { object }) {
|
||||
return reducer.reduceStaticMemberExpression(node, { object: object() });
|
||||
},
|
||||
|
||||
reduceStaticPropertyName(node) {
|
||||
return reducer.reduceStaticPropertyName(node);
|
||||
},
|
||||
|
||||
reduceSuper(node) {
|
||||
return reducer.reduceSuper(node);
|
||||
},
|
||||
|
||||
reduceSwitchCase(node, { test, consequent }) {
|
||||
return reducer.reduceSwitchCase(node, { test: test(), consequent: consequent.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceSwitchDefault(node, { consequent }) {
|
||||
return reducer.reduceSwitchDefault(node, { consequent: consequent.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceSwitchStatement(node, { discriminant, cases }) {
|
||||
return reducer.reduceSwitchStatement(node, { discriminant: discriminant(), cases: cases.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceSwitchStatementWithDefault(node, { discriminant, preDefaultCases, defaultCase, postDefaultCases }) {
|
||||
return reducer.reduceSwitchStatementWithDefault(node, { discriminant: discriminant(), preDefaultCases: preDefaultCases.map(n => n()), defaultCase: defaultCase(), postDefaultCases: postDefaultCases.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceTemplateElement(node) {
|
||||
return reducer.reduceTemplateElement(node);
|
||||
},
|
||||
|
||||
reduceTemplateExpression(node, { tag, elements }) {
|
||||
return reducer.reduceTemplateExpression(node, { tag: tag == null ? null : tag(), elements: elements.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceThisExpression(node) {
|
||||
return reducer.reduceThisExpression(node);
|
||||
},
|
||||
|
||||
reduceThrowStatement(node, { expression }) {
|
||||
return reducer.reduceThrowStatement(node, { expression: expression() });
|
||||
},
|
||||
|
||||
reduceTryCatchStatement(node, { body, catchClause }) {
|
||||
return reducer.reduceTryCatchStatement(node, { body: body(), catchClause: catchClause() });
|
||||
},
|
||||
|
||||
reduceTryFinallyStatement(node, { body, catchClause, finalizer }) {
|
||||
return reducer.reduceTryFinallyStatement(node, { body: body(), catchClause: catchClause == null ? null : catchClause(), finalizer: finalizer() });
|
||||
},
|
||||
|
||||
reduceUnaryExpression(node, { operand }) {
|
||||
return reducer.reduceUnaryExpression(node, { operand: operand() });
|
||||
},
|
||||
|
||||
reduceUpdateExpression(node, { operand }) {
|
||||
return reducer.reduceUpdateExpression(node, { operand: operand() });
|
||||
},
|
||||
|
||||
reduceVariableDeclaration(node, { declarators }) {
|
||||
return reducer.reduceVariableDeclaration(node, { declarators: declarators.map(n => n()) });
|
||||
},
|
||||
|
||||
reduceVariableDeclarationStatement(node, { declaration }) {
|
||||
return reducer.reduceVariableDeclarationStatement(node, { declaration: declaration() });
|
||||
},
|
||||
|
||||
reduceVariableDeclarator(node, { binding, init }) {
|
||||
return reducer.reduceVariableDeclarator(node, { binding: binding(), init: init == null ? null : init() });
|
||||
},
|
||||
|
||||
reduceWhileStatement(node, { test, body }) {
|
||||
return reducer.reduceWhileStatement(node, { test: test(), body: body() });
|
||||
},
|
||||
|
||||
reduceWithStatement(node, { object, body }) {
|
||||
return reducer.reduceWithStatement(node, { object: object(), body: body() });
|
||||
},
|
||||
|
||||
reduceYieldExpression(node, { expression }) {
|
||||
return reducer.reduceYieldExpression(node, { expression: expression == null ? null : expression() });
|
||||
},
|
||||
|
||||
reduceYieldGeneratorExpression(node, { expression }) {
|
||||
return reducer.reduceYieldGeneratorExpression(node, { expression: expression() });
|
||||
},
|
||||
};
|
||||
}
|
||||
61
docs/dist/shift-traverser/index.js
vendored
61
docs/dist/shift-traverser/index.js
vendored
@ -1,61 +0,0 @@
|
||||
/*
|
||||
Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com>
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
import Spec from '../../_snowpack/pkg/shift-spec.js';
|
||||
// import { version } from '../package.json'
|
||||
|
||||
// Loading uncached estraverse for changing estraverse.Syntax.
|
||||
import _estraverse from '../../_snowpack/pkg/estraverse.js';
|
||||
|
||||
const estraverse = _estraverse.cloneEnvironment();
|
||||
|
||||
// Adjust estraverse members.
|
||||
|
||||
Object.keys(estraverse.Syntax)
|
||||
.filter((key) => key !== 'Property')
|
||||
.forEach((key) => {
|
||||
delete estraverse.Syntax[key];
|
||||
delete estraverse.VisitorKeys[key];
|
||||
});
|
||||
|
||||
Object.assign(
|
||||
estraverse.Syntax,
|
||||
Object.keys(Spec).reduce((result, key) => {
|
||||
result[key] = key;
|
||||
return result;
|
||||
}, {})
|
||||
);
|
||||
|
||||
Object.assign(
|
||||
estraverse.VisitorKeys,
|
||||
Object.keys(Spec).reduce((result, key) => {
|
||||
result[key] = Spec[key].fields.map((field) => field.name);
|
||||
return result;
|
||||
}, {})
|
||||
);
|
||||
|
||||
// estraverse.version = version;
|
||||
export default estraverse;
|
||||
|
||||
/* vim: set sw=4 ts=4 et tw=80 : */
|
||||
53
docs/dist/static.js
vendored
53
docs/dist/static.js
vendored
@ -1,53 +0,0 @@
|
||||
import * as Tone from "../_snowpack/pkg/tone.js";
|
||||
import {State, TimeSpan} from "../_snowpack/link/strudel.js";
|
||||
import {getPlayableNoteValue} from "../_snowpack/link/util.js";
|
||||
import {evaluate} from "./evaluate.js";
|
||||
async function playStatic(code) {
|
||||
Tone.getTransport().cancel();
|
||||
Tone.getTransport().stop();
|
||||
let start, took;
|
||||
const seconds = Number(prompt("How many seconds to run?")) || 60;
|
||||
start = performance.now();
|
||||
console.log("evaluating..");
|
||||
const {pattern: pat} = await evaluate(code);
|
||||
took = performance.now() - start;
|
||||
console.log("evaluate took", took, "ms");
|
||||
console.log("querying..");
|
||||
start = performance.now();
|
||||
const events = pat?.query(new State(new TimeSpan(0, seconds)))?.filter((event) => event.part.begin.equals(event.whole.begin))?.map((event) => ({
|
||||
time: event.whole.begin.valueOf(),
|
||||
duration: event.whole.end.sub(event.whole.begin).valueOf(),
|
||||
value: event.value,
|
||||
context: event.context
|
||||
}));
|
||||
took = performance.now() - start;
|
||||
console.log("query took", took, "ms");
|
||||
console.log("scheduling..");
|
||||
start = performance.now();
|
||||
events.forEach((event) => {
|
||||
Tone.getTransport().schedule((time) => {
|
||||
try {
|
||||
const {onTrigger, velocity} = event.context;
|
||||
if (!onTrigger) {
|
||||
if (defaultSynth) {
|
||||
const note = getPlayableNoteValue(event);
|
||||
defaultSynth.triggerAttackRelease(note, event.duration, time, velocity);
|
||||
} else {
|
||||
throw new Error("no defaultSynth passed to useRepl.");
|
||||
}
|
||||
} else {
|
||||
onTrigger(time, event);
|
||||
}
|
||||
} catch (err) {
|
||||
console.warn(err);
|
||||
err.message = "unplayable event: " + err?.message;
|
||||
console.error(err);
|
||||
}
|
||||
}, event.time);
|
||||
});
|
||||
took = performance.now() - start;
|
||||
console.log("scheduling took", took, "ms");
|
||||
console.log("now starting!");
|
||||
Tone.getTransport().start("+0.5");
|
||||
}
|
||||
export default playStatic;
|
||||
68
docs/dist/tonal.js
vendored
68
docs/dist/tonal.js
vendored
@ -1,68 +0,0 @@
|
||||
import {Note, Interval, Scale} from "../_snowpack/pkg/@tonaljs/tonal.js";
|
||||
import {Pattern as _Pattern} from "../_snowpack/link/strudel.js";
|
||||
import {mod, tokenizeNote} from "../_snowpack/link/util.js";
|
||||
const Pattern = _Pattern;
|
||||
export function scaleTranspose(scale, offset, note) {
|
||||
let [tonic, scaleName] = Scale.tokenize(scale);
|
||||
let {notes} = Scale.get(`${tonic} ${scaleName}`);
|
||||
notes = notes.map((note2) => Note.get(note2).pc);
|
||||
offset = Number(offset);
|
||||
if (isNaN(offset)) {
|
||||
throw new Error(`scale offset "${offset}" not a number`);
|
||||
}
|
||||
const {pc: fromPc, oct = 3} = Note.get(note);
|
||||
const noteIndex = notes.indexOf(fromPc);
|
||||
if (noteIndex === -1) {
|
||||
throw new Error(`note "${note}" is not in scale "${scale}"`);
|
||||
}
|
||||
let i = noteIndex, o = oct, n = fromPc;
|
||||
const direction = Math.sign(offset);
|
||||
while (Math.abs(i - noteIndex) < Math.abs(offset)) {
|
||||
i += direction;
|
||||
const index = mod(i, notes.length);
|
||||
if (direction < 0 && n[0] === "C") {
|
||||
o += direction;
|
||||
}
|
||||
n = notes[index];
|
||||
if (direction > 0 && n[0] === "C") {
|
||||
o += direction;
|
||||
}
|
||||
}
|
||||
return n + o;
|
||||
}
|
||||
Pattern.prototype._transpose = function(intervalOrSemitones) {
|
||||
return this._withEvent((event) => {
|
||||
const interval = !isNaN(Number(intervalOrSemitones)) ? Interval.fromSemitones(intervalOrSemitones) : String(intervalOrSemitones);
|
||||
if (typeof event.value === "number") {
|
||||
const semitones = typeof interval === "string" ? Interval.semitones(interval) || 0 : interval;
|
||||
return event.withValue(() => event.value + semitones);
|
||||
}
|
||||
return event.withValue(() => Note.simplify(Note.transpose(event.value, interval)));
|
||||
});
|
||||
};
|
||||
Pattern.prototype._scaleTranspose = function(offset) {
|
||||
return this._withEvent((event) => {
|
||||
if (!event.context.scale) {
|
||||
throw new Error("can only use scaleTranspose after .scale");
|
||||
}
|
||||
if (typeof event.value !== "string") {
|
||||
throw new Error("can only use scaleTranspose with notes");
|
||||
}
|
||||
return event.withValue(() => scaleTranspose(event.context.scale, Number(offset), event.value));
|
||||
});
|
||||
};
|
||||
Pattern.prototype._scale = function(scale) {
|
||||
return this._withEvent((event) => {
|
||||
let note = event.value;
|
||||
const asNumber = Number(note);
|
||||
if (!isNaN(asNumber)) {
|
||||
let [tonic, scaleName] = Scale.tokenize(scale);
|
||||
const {pc, oct = 3} = Note.get(tonic);
|
||||
note = scaleTranspose(pc + " " + scaleName, asNumber, pc + oct);
|
||||
}
|
||||
return event.withValue(() => note).setContext({...event.context, scale});
|
||||
});
|
||||
};
|
||||
Pattern.prototype.define("transpose", (a, pat) => pat.transpose(a), {composable: true, patternified: true});
|
||||
Pattern.prototype.define("scale", (a, pat) => pat.scale(a), {composable: true, patternified: true});
|
||||
Pattern.prototype.define("scaleTranspose", (a, pat) => pat.scaleTranspose(a), {composable: true, patternified: true});
|
||||
202
docs/dist/tone.js
vendored
202
docs/dist/tone.js
vendored
@ -1,202 +0,0 @@
|
||||
import {Pattern as _Pattern} from "../_snowpack/link/strudel.js";
|
||||
import {
|
||||
AutoFilter,
|
||||
Filter,
|
||||
Gain,
|
||||
isNote,
|
||||
Synth,
|
||||
PolySynth,
|
||||
MembraneSynth,
|
||||
MetalSynth,
|
||||
MonoSynth,
|
||||
AMSynth,
|
||||
DuoSynth,
|
||||
FMSynth,
|
||||
NoiseSynth,
|
||||
PluckSynth,
|
||||
Sampler,
|
||||
getDestination,
|
||||
Players
|
||||
} from "../_snowpack/pkg/tone.js";
|
||||
import {Piano} from "../_snowpack/pkg/@tonejs/piano.js";
|
||||
import {getPlayableNoteValue} from "../_snowpack/link/util.js";
|
||||
export const defaultSynth = new PolySynth().chain(new Gain(0.5), getDestination());
|
||||
defaultSynth.set({
|
||||
oscillator: {type: "triangle"},
|
||||
envelope: {
|
||||
release: 0.01
|
||||
}
|
||||
});
|
||||
const Pattern = _Pattern;
|
||||
Pattern.prototype.tone = function(instrument) {
|
||||
return this._withEvent((event) => {
|
||||
const onTrigger = (time, event2) => {
|
||||
let note;
|
||||
let velocity = event2.context?.velocity ?? 0.75;
|
||||
switch (instrument.constructor.name) {
|
||||
case "PluckSynth":
|
||||
note = getPlayableNoteValue(event2);
|
||||
instrument.triggerAttack(note, time);
|
||||
break;
|
||||
case "NoiseSynth":
|
||||
instrument.triggerAttackRelease(event2.duration, time);
|
||||
break;
|
||||
case "Piano":
|
||||
note = getPlayableNoteValue(event2);
|
||||
instrument.keyDown({note, time, velocity});
|
||||
instrument.keyUp({note, time: time + event2.duration, velocity});
|
||||
break;
|
||||
case "Sampler":
|
||||
note = getPlayableNoteValue(event2);
|
||||
instrument.triggerAttackRelease(note, event2.duration, time, velocity);
|
||||
break;
|
||||
case "Players":
|
||||
if (!instrument.has(event2.value)) {
|
||||
throw new Error(`name "${event2.value}" not defined for players`);
|
||||
}
|
||||
const player = instrument.player(event2.value);
|
||||
player.start(time);
|
||||
player.stop(time + event2.duration);
|
||||
break;
|
||||
default:
|
||||
note = getPlayableNoteValue(event2);
|
||||
instrument.triggerAttackRelease(note, event2.duration, time, velocity);
|
||||
}
|
||||
};
|
||||
return event.setContext({...event.context, instrument, onTrigger});
|
||||
});
|
||||
};
|
||||
Pattern.prototype.define("tone", (type, pat) => pat.tone(type), {composable: true, patternified: false});
|
||||
export const amsynth = (options) => new AMSynth(options);
|
||||
export const duosynth = (options) => new DuoSynth(options);
|
||||
export const fmsynth = (options) => new FMSynth(options);
|
||||
export const membrane = (options) => new MembraneSynth(options);
|
||||
export const metal = (options) => new MetalSynth(options);
|
||||
export const monosynth = (options) => new MonoSynth(options);
|
||||
export const noise = (options) => new NoiseSynth(options);
|
||||
export const pluck = (options) => new PluckSynth(options);
|
||||
export const polysynth = (options) => new PolySynth(options);
|
||||
export const sampler = (options, baseUrl) => new Promise((resolve) => {
|
||||
const s = new Sampler(options, () => resolve(s), baseUrl);
|
||||
});
|
||||
export const players = (options, baseUrl = "") => {
|
||||
options = !baseUrl ? options : Object.fromEntries(Object.entries(options).map(([key, value]) => [key, baseUrl + value]));
|
||||
return new Promise((resolve) => {
|
||||
const s = new Players(options, () => resolve(s));
|
||||
});
|
||||
};
|
||||
export const synth = (options) => new Synth(options);
|
||||
export const piano = async (options = {velocities: 1}) => {
|
||||
const p = new Piano(options);
|
||||
await p.load();
|
||||
return p;
|
||||
};
|
||||
export const vol = (v) => new Gain(v);
|
||||
export const lowpass = (v) => new Filter(v, "lowpass");
|
||||
export const highpass = (v) => new Filter(v, "highpass");
|
||||
export const adsr = (a, d = 0.1, s = 0.4, r = 0.01) => ({envelope: {attack: a, decay: d, sustain: s, release: r}});
|
||||
export const osc = (type) => ({oscillator: {type}});
|
||||
export const out = () => getDestination();
|
||||
const chainable = function(instr) {
|
||||
const _chain = instr.chain.bind(instr);
|
||||
let chained = [];
|
||||
instr.chain = (...args) => {
|
||||
chained = chained.concat(args);
|
||||
instr.disconnect();
|
||||
return _chain(...chained, getDestination());
|
||||
};
|
||||
instr.filter = (freq = 1e3, type = "lowpass") => instr.chain(new Filter(freq, type));
|
||||
instr.gain = (gain2 = 0.9) => instr.chain(new Gain(gain2));
|
||||
return instr;
|
||||
};
|
||||
export const poly = (type) => {
|
||||
const s = new PolySynth(Synth, {oscillator: {type}}).toDestination();
|
||||
return chainable(s);
|
||||
};
|
||||
Pattern.prototype._poly = function(type = "triangle") {
|
||||
const instrumentConfig = {
|
||||
oscillator: {type},
|
||||
envelope: {attack: 0.01, decay: 0.01, sustain: 0.6, release: 0.01}
|
||||
};
|
||||
if (!this.instrument) {
|
||||
this.instrument = poly(type);
|
||||
}
|
||||
return this._withEvent((event) => {
|
||||
const onTrigger = (time, event2) => {
|
||||
this.instrument.set(instrumentConfig);
|
||||
this.instrument.triggerAttackRelease(event2.value, event2.duration, time);
|
||||
};
|
||||
return event.setContext({...event.context, instrumentConfig, onTrigger});
|
||||
});
|
||||
};
|
||||
Pattern.prototype.define("poly", (type, pat) => pat.poly(type), {composable: true, patternified: true});
|
||||
const getTrigger = (getChain, value) => (time, event) => {
|
||||
const chain = getChain();
|
||||
if (!isNote(value)) {
|
||||
throw new Error("not a note: " + value);
|
||||
}
|
||||
chain.triggerAttackRelease(value, event.duration, time);
|
||||
setTimeout(() => {
|
||||
chain.dispose();
|
||||
}, event.duration * 2e3);
|
||||
};
|
||||
Pattern.prototype._synth = function(type = "triangle") {
|
||||
return this._withEvent((event) => {
|
||||
const instrumentConfig = {
|
||||
oscillator: {type},
|
||||
envelope: {attack: 0.01, decay: 0.01, sustain: 0.6, release: 0.01}
|
||||
};
|
||||
const getInstrument = () => {
|
||||
const instrument = new Synth();
|
||||
instrument.set(instrumentConfig);
|
||||
return instrument;
|
||||
};
|
||||
const onTrigger = getTrigger(() => getInstrument().toDestination(), event.value);
|
||||
return event.setContext({...event.context, getInstrument, instrumentConfig, onTrigger});
|
||||
});
|
||||
};
|
||||
Pattern.prototype.adsr = function(attack = 0.01, decay = 0.01, sustain = 0.6, release = 0.01) {
|
||||
return this._withEvent((event) => {
|
||||
if (!event.context.getInstrument) {
|
||||
throw new Error("cannot chain adsr: need instrument first (like synth)");
|
||||
}
|
||||
const instrumentConfig = {...event.context.instrumentConfig, envelope: {attack, decay, sustain, release}};
|
||||
const getInstrument = () => {
|
||||
const instrument = event.context.getInstrument();
|
||||
instrument.set(instrumentConfig);
|
||||
return instrument;
|
||||
};
|
||||
const onTrigger = getTrigger(() => getInstrument().toDestination(), event.value);
|
||||
return event.setContext({...event.context, getInstrument, instrumentConfig, onTrigger});
|
||||
});
|
||||
};
|
||||
Pattern.prototype.chain = function(...effectGetters) {
|
||||
return this._withEvent((event) => {
|
||||
if (!event.context?.getInstrument) {
|
||||
throw new Error("cannot chain: need instrument first (like synth)");
|
||||
}
|
||||
const chain = (event.context.chain || []).concat(effectGetters);
|
||||
const getChain = () => {
|
||||
const effects = chain.map((getEffect) => getEffect());
|
||||
return event.context.getInstrument().chain(...effects, getDestination());
|
||||
};
|
||||
const onTrigger = getTrigger(getChain, event.value);
|
||||
return event.setContext({...event.context, getChain, onTrigger, chain});
|
||||
});
|
||||
};
|
||||
export const autofilter = (freq = 1) => () => new AutoFilter(freq).start();
|
||||
export const filter = (freq = 1, q = 1, type = "lowpass") => () => new Filter(freq, type);
|
||||
export const gain = (gain2 = 0.9) => () => new Gain(gain2);
|
||||
Pattern.prototype._gain = function(g) {
|
||||
return this.chain(gain(g));
|
||||
};
|
||||
Pattern.prototype._filter = function(freq, q, type = "lowpass") {
|
||||
return this.chain(filter(freq, q, type));
|
||||
};
|
||||
Pattern.prototype._autofilter = function(g) {
|
||||
return this.chain(autofilter(g));
|
||||
};
|
||||
Pattern.prototype.define("synth", (type, pat) => pat.synth(type), {composable: true, patternified: true});
|
||||
Pattern.prototype.define("gain", (gain2, pat) => pat.synth(gain2), {composable: true, patternified: true});
|
||||
Pattern.prototype.define("filter", (cutoff, pat) => pat.filter(cutoff), {composable: true, patternified: true});
|
||||
Pattern.prototype.define("autofilter", (cutoff, pat) => pat.filter(cutoff), {composable: true, patternified: true});
|
||||
14
docs/dist/tune.js
vendored
14
docs/dist/tune.js
vendored
@ -1,14 +0,0 @@
|
||||
import Tune from "./tunejs.js";
|
||||
import {Pattern} from "../_snowpack/link/strudel.js";
|
||||
Pattern.prototype._tune = function(scale, tonic = 220) {
|
||||
const tune = new Tune();
|
||||
if (!tune.isValidScale(scale)) {
|
||||
throw new Error('not a valid tune.js scale name: "' + scale + '". See http://abbernie.github.io/tune/scales.html');
|
||||
}
|
||||
tune.loadScale(scale);
|
||||
tune.tonicize(tonic);
|
||||
return this._asNumber()._withEvent((event) => {
|
||||
return event.withValue(() => tune.note(event.value)).setContext({...event.context, type: "frequency"});
|
||||
});
|
||||
};
|
||||
Pattern.prototype.define("tune", (scale, pat) => pat.tune(scale), {composable: true, patternified: true});
|
||||
233
docs/dist/tunejs.js
vendored
233
docs/dist/tunejs.js
vendored
File diff suppressed because one or more lines are too long
632
docs/dist/tunes.js
vendored
632
docs/dist/tunes.js
vendored
@ -1,632 +0,0 @@
|
||||
export const timeCatMini = `stack(
|
||||
"c3@3 [eb3, g3, [c4 d4]/2]",
|
||||
"c2 g2",
|
||||
"[eb4@5 [f4 eb4 d4]@3] [eb4 c4]/2".slow(8)
|
||||
)`;
|
||||
export const timeCat = `stack(
|
||||
timeCat([3, c3], [1, stack(eb3, g3, cat(c4, d4).slow(2))]),
|
||||
cat(c2, g2),
|
||||
sequence(
|
||||
timeCat([5, eb4], [3, cat(f4, eb4, d4)]),
|
||||
cat(eb4, c4).slow(2)
|
||||
).slow(4)
|
||||
)`;
|
||||
export const shapeShifted = `stack(
|
||||
sequence(
|
||||
e5, [b4, c5], d5, [c5, b4],
|
||||
a4, [a4, c5], e5, [d5, c5],
|
||||
b4, [r, c5], d5, e5,
|
||||
c5, a4, a4, r,
|
||||
[r, d5], [r, f5], a5, [g5, f5],
|
||||
e5, [r, c5], e5, [d5, c5],
|
||||
b4, [b4, c5], d5, e5,
|
||||
c5, a4, a4, r,
|
||||
).rev(),
|
||||
sequence(
|
||||
e2, e3, e2, e3, e2, e3, e2, e3,
|
||||
a2, a3, a2, a3, a2, a3, a2, a3,
|
||||
gs2, gs3, gs2, gs3, e2, e3, e2, e3,
|
||||
a2, a3, a2, a3, a2, a3, b1, c2,
|
||||
d2, d3, d2, d3, d2, d3, d2, d3,
|
||||
c2, c3, c2, c3, c2, c3, c2, c3,
|
||||
b1, b2, b1, b2, e2, e3, e2, e3,
|
||||
a1, a2, a1, a2, a1, a2, a1, a2,
|
||||
).rev()
|
||||
).slow(16)`;
|
||||
export const tetrisWithFunctions = `stack(sequence(
|
||||
'e5', sequence('b4', 'c5'), 'd5', sequence('c5', 'b4'),
|
||||
'a4', sequence('a4', 'c5'), 'e5', sequence('d5', 'c5'),
|
||||
'b4', sequence(silence, 'c5'), 'd5', 'e5',
|
||||
'c5', 'a4', 'a4', silence,
|
||||
sequence(silence, 'd5'), sequence(silence, 'f5'), 'a5', sequence('g5', 'f5'),
|
||||
'e5', sequence(silence, 'c5'), 'e5', sequence('d5', 'c5'),
|
||||
'b4', sequence('b4', 'c5'), 'd5', 'e5',
|
||||
'c5', 'a4', 'a4', silence),
|
||||
sequence(
|
||||
'e2', 'e3', 'e2', 'e3', 'e2', 'e3', 'e2', 'e3',
|
||||
'a2', 'a3', 'a2', 'a3', 'a2', 'a3', 'a2', 'a3',
|
||||
'g#2', 'g#3', 'g#2', 'g#3', 'e2', 'e3', 'e2', 'e3',
|
||||
'a2', 'a3', 'a2', 'a3', 'a2', 'a3', 'b1', 'c2',
|
||||
'd2', 'd3', 'd2', 'd3', 'd2', 'd3', 'd2', 'd3',
|
||||
'c2', 'c3', 'c2', 'c3', 'c2', 'c3', 'c2', 'c3',
|
||||
'b1', 'b2', 'b1', 'b2', 'e2', 'e3', 'e2', 'e3',
|
||||
'a1', 'a2', 'a1', 'a2', 'a1', 'a2', 'a1', 'a2',
|
||||
)
|
||||
).slow(16)`;
|
||||
export const tetris = `stack(
|
||||
cat(
|
||||
"e5 [b4 c5] d5 [c5 b4]",
|
||||
"a4 [a4 c5] e5 [d5 c5]",
|
||||
"b4 [~ c5] d5 e5",
|
||||
"c5 a4 a4 ~",
|
||||
"[~ d5] [~ f5] a5 [g5 f5]",
|
||||
"e5 [~ c5] e5 [d5 c5]",
|
||||
"b4 [b4 c5] d5 e5",
|
||||
"c5 a4 a4 ~"
|
||||
),
|
||||
cat(
|
||||
"e2 e3 e2 e3 e2 e3 e2 e3",
|
||||
"a2 a3 a2 a3 a2 a3 a2 a3",
|
||||
"g#2 g#3 g#2 g#3 e2 e3 e2 e3",
|
||||
"a2 a3 a2 a3 a2 a3 b1 c2",
|
||||
"d2 d3 d2 d3 d2 d3 d2 d3",
|
||||
"c2 c3 c2 c3 c2 c3 c2 c3",
|
||||
"b1 b2 b1 b2 e2 e3 e2 e3",
|
||||
"a1 a2 a1 a2 a1 a2 a1 a2",
|
||||
)
|
||||
).slow(16)`;
|
||||
export const tetrisMini = `\`[[e5 [b4 c5] d5 [c5 b4]]
|
||||
[a4 [a4 c5] e5 [d5 c5]]
|
||||
[b4 [~ c5] d5 e5]
|
||||
[c5 a4 a4 ~]
|
||||
[[~ d5] [~ f5] a5 [g5 f5]]
|
||||
[e5 [~ c5] e5 [d5 c5]]
|
||||
[b4 [b4 c5] d5 e5]
|
||||
[c5 a4 a4 ~]],
|
||||
[[e2 e3]*4]
|
||||
[[a2 a3]*4]
|
||||
[[g#2 g#3]*2 [e2 e3]*2]
|
||||
[a2 a3 a2 a3 a2 a3 b1 c2]
|
||||
[[d2 d3]*4]
|
||||
[[c2 c3]*4]
|
||||
[[b1 b2]*2 [e2 e3]*2]
|
||||
[[a1 a2]*4]\`.slow(16)
|
||||
`;
|
||||
export const whirlyStrudel = `sequence(e4, [b2, b3], c4)
|
||||
.every(4, fast(2))
|
||||
.every(3, slow(1.5))
|
||||
.fast(slowcat(1.25, 1, 1.5))
|
||||
.every(2, _ => sequence(e4, r, e3, d4, r))`;
|
||||
export const swimming = `stack(
|
||||
cat(
|
||||
"~",
|
||||
"~",
|
||||
"~",
|
||||
"A5 [F5@2 C5] [D5@2 F5] F5",
|
||||
"[C5@2 F5] [F5@2 C6] A5 G5",
|
||||
"A5 [F5@2 C5] [D5@2 F5] F5",
|
||||
"[C5@2 F5] [Bb5 A5 G5] F5@2",
|
||||
"A5 [F5@2 C5] [D5@2 F5] F5",
|
||||
"[C5@2 F5] [F5@2 C6] A5 G5",
|
||||
"A5 [F5@2 C5] [D5@2 F5] F5",
|
||||
"[C5@2 F5] [Bb5 A5 G5] F5@2",
|
||||
"A5 [F5@2 C5] A5 F5",
|
||||
"Ab5 [F5@2 Ab5] G5@2",
|
||||
"A5 [F5@2 C5] A5 F5",
|
||||
"Ab5 [F5@2 C5] C6@2",
|
||||
"A5 [F5@2 C5] [D5@2 F5] F5",
|
||||
"[C5@2 F5] [Bb5 A5 G5] F5@2"
|
||||
),
|
||||
cat(
|
||||
"[F4,Bb4,D5] [[D4,G4,Bb4]@2 [Bb3,D4,F4]] [[G3,C4,E4]@2 [[Ab3,F4] [A3,Gb4]]] [Bb3,E4,G4]",
|
||||
"[~ [F3, A3, C3] [F3, A3, C3]] [~ [F3, A3, C3] [F3, A3, C3]] [~ [F3, Bb3, D3] [F3, Bb3, D3]] [~ [F3, Bb3, Db3] [F3, Bb3, Db3]]",
|
||||
"[~ [F3, A3, C3] [F3, A3, C3]] [~ [F3, A3, C3] [F3, A3, C3]] [~ [F3, Bb3, D3] [F3, Bb3, D3]] [~ [F3, B3, D3] [F3, B3, D3]]",
|
||||
"[~ [F3, A3, C3] [F3, A3, C3]] [~ [F3, A3, C3] [F3, A3, C3]] [~ [F3, Bb3, D3] [F3, Bb3, D3]] [~ [F3, B3, D3] [F3, B3, D3]]",
|
||||
"[~ [A3, C4, E4] [A3, C4, E4]] [~ [Ab3, C4, Eb4] [Ab3, C4, Eb4]] [~ [F3, Bb3, D3] [F3, Bb3, D3]] [~ [G3, C4, E4] [G3, C4, E4]]",
|
||||
"[~ [F3, A3, C4] [F3, A3, C4]] [~ [F3, A3, C4] [F3, A3, C4]] [~ [F3, Bb3, D3] [F3, Bb3, D3]] [~ [F3, B3, D3] [F3, B3, D3]]",
|
||||
"[~ [F3, Bb3, D4] [F3, Bb3, D4]] [~ [F3, Bb3, C4] [F3, Bb3, C4]] [~ [F3, A3, C4] [F3, A3, C4]] [~ [F3, A3, C4] [F3, A3, C4]]",
|
||||
"[~ [F3, A3, C3] [F3, A3, C3]] [~ [F3, A3, C3] [F3, A3, C3]] [~ [F3, Bb3, D3] [F3, Bb3, D3]] [~ [F3, B3, D3] [F3, B3, D3]]",
|
||||
"[~ [A3, C4, E4] [A3, C4, E4]] [~ [Ab3, C4, Eb4] [Ab3, C4, Eb4]] [~ [F3, Bb3, D3] [F3, Bb3, D3]] [~ [G3, C4, E4] [G3, C4, E4]]",
|
||||
"[~ [F3, A3, C3] [F3, A3, C3]] [~ [F3, A3, C3] [F3, A3, C3]] [~ [F3, Bb3, D3] [F3, Bb3, D3]] [~ [F3, B3, D3] [F3, B3, D3]]",
|
||||
"[~ [F3, Bb3, D4] [F3, Bb3, D4]] [~ [F3, Bb3, C4] [F3, Bb3, C4]] [~ [F3, A3, C4] [F3, A3, C4]] [~ [F3, A3, C4] [F3, A3, C4]]",
|
||||
"[~ [Bb3, D3, F4] [Bb3, D3, F4]] [~ [Bb3, D3, F4] [Bb3, D3, F4]] [~ [A3, C4, F4] [A3, C4, F4]] [~ [A3, C4, F4] [A3, C4, F4]]",
|
||||
"[~ [Ab3, B3, F4] [Ab3, B3, F4]] [~ [Ab3, B3, F4] [Ab3, B3, F4]] [~ [G3, Bb3, F4] [G3, Bb3, F4]] [~ [G3, Bb3, E4] [G3, Bb3, E4]]",
|
||||
"[~ [Bb3, D3, F4] [Bb3, D3, F4]] [~ [Bb3, D3, F4] [Bb3, D3, F4]] [~ [A3, C4, F4] [A3, C4, F4]] [~ [A3, C4, F4] [A3, C4, F4]]",
|
||||
"[~ [Ab3, B3, F4] [Ab3, B3, F4]] [~ [Ab3, B3, F4] [Ab3, B3, F4]] [~ [G3, Bb3, F4] [G3, Bb3, F4]] [~ [G3, Bb3, E4] [G3, Bb3, E4]]",
|
||||
"[~ [F3, A3, C3] [F3, A3, C3]] [~ [F3, A3, C3] [F3, A3, C3]] [~ [F3, Bb3, D3] [F3, Bb3, D3]] [~ [F3, B3, D3] [F3, B3, D3]]",
|
||||
"[~ [F3, Bb3, D4] [F3, Bb3, D4]] [~ [F3, Bb3, C4] [F3, Bb3, C4]] [~ [F3, A3, C4] [F3, A3, C4]] [~ [F3, A3, C4] [F3, A3, C4]]"
|
||||
),
|
||||
cat(
|
||||
"[G3 G3 C3 E3]",
|
||||
"[F2 D2 G2 C2]",
|
||||
"[F2 D2 G2 C2]",
|
||||
"[F2 A2 Bb2 B2]",
|
||||
"[A2 Ab2 G2 C2]",
|
||||
"[F2 A2 Bb2 B2]",
|
||||
"[G2 C2 F2 F2]",
|
||||
"[F2 A2 Bb2 B2]",
|
||||
"[A2 Ab2 G2 C2]",
|
||||
"[F2 A2 Bb2 B2]",
|
||||
"[G2 C2 F2 F2]",
|
||||
"[Bb2 Bb2 A2 A2]",
|
||||
"[Ab2 Ab2 G2 [C2 D2 E2]]",
|
||||
"[Bb2 Bb2 A2 A2]",
|
||||
"[Ab2 Ab2 G2 [C2 D2 E2]]",
|
||||
"[F2 A2 Bb2 B2]",
|
||||
"[G2 C2 F2 F2]"
|
||||
)
|
||||
).slow(51);
|
||||
`;
|
||||
export const giantSteps = `stack(
|
||||
// melody
|
||||
cat(
|
||||
"[F#5 D5] [B4 G4] Bb4 [B4 A4]",
|
||||
"[D5 Bb4] [G4 Eb4] F#4 [G4 F4]",
|
||||
"Bb4 [B4 A4] D5 [D#5 C#5]",
|
||||
"F#5 [G5 F5] Bb5 [F#5 F#5]",
|
||||
),
|
||||
// chords
|
||||
cat(
|
||||
"[B^7 D7] [G^7 Bb7] Eb^7 [Am7 D7]",
|
||||
"[G^7 Bb7] [Eb^7 F#7] B^7 [Fm7 Bb7]",
|
||||
"Eb^7 [Am7 D7] G^7 [C#m7 F#7]",
|
||||
"B^7 [Fm7 Bb7] Eb^7 [C#m7 F#7]"
|
||||
).voicings(['E3', 'G4']),
|
||||
// bass
|
||||
cat(
|
||||
"[B2 D2] [G2 Bb2] [Eb2 Bb3] [A2 D2]",
|
||||
"[G2 Bb2] [Eb2 F#2] [B2 F#2] [F2 Bb2]",
|
||||
"[Eb2 Bb2] [A2 D2] [G2 D2] [C#2 F#2]",
|
||||
"[B2 F#2] [F2 Bb2] [Eb2 Bb3] [C#2 F#2]"
|
||||
)
|
||||
).slow(20);`;
|
||||
export const giantStepsReggae = `stack(
|
||||
// melody
|
||||
cat(
|
||||
"[F#5 D5] [B4 G4] Bb4 [B4 A4]",
|
||||
"[D5 Bb4] [G4 Eb4] F#4 [G4 F4]",
|
||||
"Bb4 [B4 A4] D5 [D#5 C#5]",
|
||||
"F#5 [G5 F5] Bb5 [F#5 [F#5 ~@3]]",
|
||||
),
|
||||
// chords
|
||||
cat(
|
||||
"[B^7 D7] [G^7 Bb7] Eb^7 [Am7 D7]",
|
||||
"[G^7 Bb7] [Eb^7 F#7] B^7 [Fm7 Bb7]",
|
||||
"Eb^7 [Am7 D7] G^7 [C#m7 F#7]",
|
||||
"B^7 [Fm7 Bb7] Eb^7 [C#m7 F#7]"
|
||||
)
|
||||
.struct("~ [x ~]".fast(4*8))
|
||||
.voicings(['E3', 'G4']),
|
||||
// bass
|
||||
cat(
|
||||
"[B2 D2] [G2 D2] [Eb2 Bb2] [A2 D2]",
|
||||
"[G2 Bb2] [Eb2 F#2] [B2 F#2] [F2 Bb2]",
|
||||
"[Eb2 Bb2] [A2 D2] [G2 D2] [C#2 F#2]",
|
||||
"[B2 F#2] [F2 Bb2] [Eb2 Bb2] [C#2 F#2]"
|
||||
)
|
||||
.struct("x ~".fast(4*8))
|
||||
).slow(25)`;
|
||||
export const transposedChordsHacked = `stack(
|
||||
"c2 eb2 g2",
|
||||
"Cm7".voicings(['g2','c4']).slow(2)
|
||||
).transpose(
|
||||
slowcat(1, 2, 3, 2).slow(2)
|
||||
).transpose(5)`;
|
||||
export const scaleTranspose = `stack(f2, f3, c4, ab4)
|
||||
.scale(sequence('F minor', 'F harmonic minor').slow(4))
|
||||
.scaleTranspose(sequence(0, -1, -2, -3).slow(4))
|
||||
.transpose(sequence(0, 1).slow(16))`;
|
||||
export const struct = `stack(
|
||||
"c2 g2 a2 [e2@2 eb2] d2 a2 g2 [d2 ~ db2]",
|
||||
"[C^7 A7] [Dm7 G7]".struct("[x@2 x] [~@2 x] [~ x@2]@2 [x ~@2] ~ [~@2 x@4]@2")
|
||||
.voicings(['G3','A4'])
|
||||
).slow(4)`;
|
||||
export const magicSofa = `stack(
|
||||
"<C^7 F^7 ~> <Dm7 G7 A7 ~>"
|
||||
.every(2, fast(2))
|
||||
.voicings(),
|
||||
"<c2 f2 g2> <d2 g2 a2 e2>"
|
||||
).slow(1).transpose(slowcat(0, 2, 3, 4))`;
|
||||
export const confusedPhone = `"[g2 ~@1.3] [c3 ~@1.3]"
|
||||
.superimpose(
|
||||
transpose(-12).late(0),
|
||||
transpose(7).late(0.1),
|
||||
transpose(10).late(0.2),
|
||||
transpose(12).late(0.3),
|
||||
transpose(24).late(0.4)
|
||||
)
|
||||
.scale(slowcat('C dorian', 'C mixolydian'))
|
||||
.scaleTranspose(slowcat(0,1,2,1))
|
||||
.slow(2)`;
|
||||
export const zeldasRescue = `stack(
|
||||
// melody
|
||||
\`[B3@2 D4] [A3@2 [G3 A3]] [B3@2 D4] [A3]
|
||||
[B3@2 D4] [A4@2 G4] [D4@2 [C4 B3]] [A3]
|
||||
[B3@2 D4] [A3@2 [G3 A3]] [B3@2 D4] [A3]
|
||||
[B3@2 D4] [A4@2 G4] D5@2
|
||||
[D5@2 [C5 B4]] [[C5 B4] G4@2] [C5@2 [B4 A4]] [[B4 A4] E4@2]
|
||||
[D5@2 [C5 B4]] [[C5 B4] G4 C5] [G5] [~ ~ B3]\`,
|
||||
// bass
|
||||
\`[[C2 G2] E3@2] [[C2 G2] F#3@2] [[C2 G2] E3@2] [[C2 G2] F#3@2]
|
||||
[[B1 D3] G3@2] [[Bb1 Db3] G3@2] [[A1 C3] G3@2] [[D2 C3] F#3@2]
|
||||
[[C2 G2] E3@2] [[C2 G2] F#3@2] [[C2 G2] E3@2] [[C2 G2] F#3@2]
|
||||
[[B1 D3] G3@2] [[Bb1 Db3] G3@2] [[A1 C3] G3@2] [[D2 C3] F#3@2]
|
||||
[[F2 C3] E3@2] [[E2 B2] D3@2] [[D2 A2] C3@2] [[C2 G2] B2@2]
|
||||
[[F2 C3] E3@2] [[E2 B2] D3@2] [[Eb2 Bb2] Db3@2] [[D2 A2] C3 [F3,G2]]\`
|
||||
).transpose(12).slow(48).tone(
|
||||
new PolySynth().chain(
|
||||
new Gain(0.3),
|
||||
new Chorus(2, 2.5, 0.5).start(),
|
||||
new Freeverb(),
|
||||
getDestination())
|
||||
)`;
|
||||
export const technoDrums = `stack(
|
||||
"c1*2".tone(new Tone.MembraneSynth().toDestination()),
|
||||
"~ x".tone(new Tone.NoiseSynth().toDestination()),
|
||||
"[~ c4]*2".tone(new Tone.MetalSynth().set({envelope:{decay:0.06,sustain:0}}).chain(new Gain(0.5),getDestination()))
|
||||
)`;
|
||||
export const loungerave = `const delay = new FeedbackDelay(1/8, .2).chain(vol(0.5), out());
|
||||
const kick = new MembraneSynth().chain(vol(.8), out());
|
||||
const snare = new NoiseSynth().chain(vol(.8), out());
|
||||
const hihat = new MetalSynth().set(adsr(0, .08, 0, .1)).chain(vol(.3).connect(delay),out());
|
||||
const bass = new Synth().set({ ...osc('sawtooth'), ...adsr(0, .1, .4) }).chain(lowpass(900), vol(.5), out());
|
||||
const keys = new PolySynth().set({ ...osc('sawtooth'), ...adsr(0, .5, .2, .7) }).chain(lowpass(1200), vol(.5), out());
|
||||
|
||||
const drums = stack(
|
||||
"c1*2".tone(kick).mask("<x@7 ~>/8"),
|
||||
"~ <x!7 [x@3 x]>".tone(snare).mask("<x@7 ~>/4"),
|
||||
"[~ c4]*2".tone(hihat)
|
||||
);
|
||||
|
||||
const thru = (x) => x.transpose("<0 1>/8").transpose(1);
|
||||
const synths = stack(
|
||||
"<C2 Bb1 Ab1 [G1 [G2 G1]]>/2".struct("[x [~ x] <[~ [~ x]]!3 [x x]>@2]/2").edit(thru).tone(bass),
|
||||
"<Cm7 Bb7 Fm7 G7b9>/2".struct("~ [x@0.1 ~]").voicings().edit(thru).every(2, early(1/4)).tone(keys).mask("<x@7 ~>/8".early(1/4))
|
||||
)
|
||||
stack(
|
||||
drums,
|
||||
synths
|
||||
)`;
|
||||
export const caverave = `const delay = new FeedbackDelay(1/8, .4).chain(vol(0.5), out());
|
||||
const kick = new MembraneSynth().chain(vol(.8), out());
|
||||
const snare = new NoiseSynth().chain(vol(.8), out());
|
||||
const hihat = new MetalSynth().set(adsr(0, .08, 0, .1)).chain(vol(.3).connect(delay),out());
|
||||
const bass = new Synth().set({ ...osc('sawtooth'), ...adsr(0, .1, .4) }).chain(lowpass(900), vol(.5), out());
|
||||
const keys = new PolySynth().set({ ...osc('sawtooth'), ...adsr(0, .5, .2, .7) }).chain(lowpass(1200), vol(.5), out());
|
||||
|
||||
const drums = stack(
|
||||
"c1*2".tone(kick).mask("<x@7 ~>/8"),
|
||||
"~ <x!7 [x@3 x]>".tone(snare).mask("<x@7 ~>/4"),
|
||||
"[~ c4]*2".tone(hihat)
|
||||
);
|
||||
|
||||
const thru = (x) => x.transpose("<0 1>/8").transpose(-1);
|
||||
const synths = stack(
|
||||
"<eb4 d4 c4 b3>/2".scale(timeCat([3,'C minor'],[1,'C melodic minor']).slow(8)).struct("[~ x]*2")
|
||||
.edit(
|
||||
scaleTranspose(0).early(0),
|
||||
scaleTranspose(2).early(1/8),
|
||||
scaleTranspose(7).early(1/4),
|
||||
scaleTranspose(8).early(3/8)
|
||||
).apply(thru).tone(keys).mask("<~ x>/16"),
|
||||
"<C2 Bb1 Ab1 [G1 [G2 G1]]>/2".struct("[x [~ x] <[~ [~ x]]!3 [x x]>@2]/2".fast(2)).apply(thru).tone(bass),
|
||||
"<Cm7 Bb7 Fm7 G7b13>/2".struct("~ [x@0.1 ~]".fast(2)).voicings().apply(thru).every(2, early(1/8)).tone(keys).mask("<x@7 ~>/8".early(1/4))
|
||||
)
|
||||
stack(
|
||||
drums.fast(2),
|
||||
synths
|
||||
).slow(2)`;
|
||||
export const callcenterhero = `const bpm = 90;
|
||||
const lead = polysynth().set({...osc('sine4'),...adsr(.004)}).chain(vol(0.15),out())
|
||||
const bass = fmsynth({...osc('sawtooth6'),...adsr(0.05,.6,0.8,0.1)}).chain(vol(0.6), out());
|
||||
const s = scale(slowcat('F3 minor', 'Ab3 major', 'Bb3 dorian', 'C4 phrygian dominant').slow(4));
|
||||
stack(
|
||||
"0 2".struct("<x ~> [x ~]").apply(s).scaleTranspose(stack(0,2)).tone(lead),
|
||||
"<6 7 9 7>".struct("[~ [x ~]*2]*2").apply(s).scaleTranspose("[0,2] [2,4]".fast(2).every(4,rev)).tone(lead),
|
||||
"-14".struct("[~ x@0.8]*2".early(0.01)).apply(s).tone(bass),
|
||||
"c2*2".tone(membrane().chain(vol(0.6), out())),
|
||||
"~ c2".tone(noise().chain(vol(0.2), out())),
|
||||
"c4*4".tone(metal(adsr(0,.05,0)).chain(vol(0.03), out()))
|
||||
)
|
||||
.slow(120 / bpm)`;
|
||||
export const primalEnemy = `const f = fast("<1 <2 [4 8]>>");
|
||||
stack(
|
||||
"c3,g3,c4".struct("[x ~]*2").apply(f).transpose("<0 <3 [5 [7 [9 [11 13]]]]>>"),
|
||||
"c2 [c2 ~]*2".tone(synth(osc('sawtooth8')).chain(vol(0.8),out())),
|
||||
"c1*2".tone(membrane().chain(vol(0.8),out()))
|
||||
).slow(1)`;
|
||||
export const synthDrums = `stack(
|
||||
"c1*2".tone(membrane().chain(vol(0.8),out())),
|
||||
"~ c3".tone(noise().chain(vol(0.8),out())),
|
||||
"c3*4".transpose("[-24 0]*2").tone(metal(adsr(0,.015)).chain(vol(0.8),out()))
|
||||
)
|
||||
`;
|
||||
export const sampleDrums = `const drums = await players({
|
||||
bd: 'bd/BT0A0D0.wav',
|
||||
sn: 'sn/ST0T0S3.wav',
|
||||
hh: 'hh/000_hh3closedhh.wav'
|
||||
}, 'https://loophole-letters.vercel.app/samples/tidal/')
|
||||
|
||||
stack(
|
||||
"<bd!3 bd(3,4,2)>",
|
||||
"hh*4",
|
||||
"~ <sn!3 sn(3,4,1)>"
|
||||
).tone(drums.chain(out()))
|
||||
`;
|
||||
export const xylophoneCalling = `const t = x => x.scaleTranspose("<0 2 4 3>/4").transpose(-2)
|
||||
const s = x => x.scale(slowcat('C3 minor pentatonic','G3 minor pentatonic').slow(4))
|
||||
const delay = new FeedbackDelay(1/8, .6).chain(vol(0.1), out());
|
||||
const chorus = new Chorus(1,2.5,0.5).start();
|
||||
stack(
|
||||
// melody
|
||||
"<<10 7> <8 3>>/4".struct("x*3").apply(s)
|
||||
.scaleTranspose("<0 3 2> <1 4 3>")
|
||||
.superimpose(scaleTranspose(2).early(1/8))
|
||||
.apply(t).tone(polysynth().set({
|
||||
...osc('triangle4'),
|
||||
...adsr(0,.08,0)
|
||||
}).chain(vol(0.2).connect(delay),chorus,out())).mask("<~@3 x>/16".early(1/8)),
|
||||
// pad
|
||||
"[1,3]/4".scale('G3 minor pentatonic').apply(t).tone(polysynth().set({
|
||||
...osc('square2'),
|
||||
...adsr(0.1,.4,0.8)
|
||||
}).chain(vol(0.2),chorus,out())).mask("<~ x>/32"),
|
||||
// xylophone
|
||||
"c3,g3,c4".struct("<x*2 x>").fast("<1 <2!3 [4 8]>>").apply(s).scaleTranspose("<0 <1 [2 [3 <4 5>]]>>").apply(t).tone(polysynth().set({
|
||||
...osc('sawtooth4'),
|
||||
...adsr(0,.1,0)
|
||||
}).chain(vol(0.4).connect(delay),out())).mask("<x@3 ~>/16".early(1/8)),
|
||||
// bass
|
||||
"c2 [c2 ~]*2".scale('C hirajoshi').apply(t).tone(synth({
|
||||
...osc('sawtooth6'),
|
||||
...adsr(0,.03,.4,.1)
|
||||
}).chain(vol(0.4),out())),
|
||||
// kick
|
||||
"<c1!3 [c1 ~]*2>*2".tone(membrane().chain(vol(0.8),out())),
|
||||
// snare
|
||||
"~ <c3!7 [c3 c3*2]>".tone(noise().chain(vol(0.8),out())),
|
||||
// hihat
|
||||
"c3*4".transpose("[-24 0]*2").tone(metal(adsr(0,.02)).chain(vol(0.5).connect(delay),out()))
|
||||
).slow(1)`;
|
||||
export const sowhatelse = `// mixer
|
||||
const mix = (key) => vol({
|
||||
chords: .2,
|
||||
lead: 0.8,
|
||||
bass: .4,
|
||||
snare: .95,
|
||||
kick: .9,
|
||||
hihat: .35,
|
||||
}[key]||0);
|
||||
const delay = new FeedbackDelay(1/6, .3).chain(vol(.7), out());
|
||||
const delay2 = new FeedbackDelay(1/6, .2).chain(vol(.15), out());
|
||||
const chorus = new Chorus(1,2.5,0.5).start();
|
||||
// instruments
|
||||
const instr = (instrument) => ({
|
||||
organ: polysynth().set({...osc('sawtooth4'), ...adsr(.01,.2,0)}).chain(mix('chords').connect(delay),out()),
|
||||
lead: polysynth().set({...osc('triangle4'),...adsr(0.01,.05,0)}).chain(mix('lead').connect(delay2), out()),
|
||||
bass: polysynth().set({...osc('sawtooth8'),...adsr(.02,.05,.3,.2)}).chain(mix('bass'),lowpass(3000), out()),
|
||||
pad: polysynth().set({...osc('square2'),...adsr(0.1,.4,0.8)}).chain(vol(0.15),chorus,out()),
|
||||
hihat: metal(adsr(0, .02, 0)).chain(mix('hihat'), out()),
|
||||
snare: noise(adsr(0, .15, 0.01)).chain(mix('snare'), lowpass(5000), out()),
|
||||
kick: membrane().chain(mix('kick'), out())
|
||||
}[instrument]);
|
||||
// harmony
|
||||
const t = transpose("<0 0 1 0>/8");
|
||||
const sowhat = scaleTranspose("0,3,6,9,11");
|
||||
// track
|
||||
stack(
|
||||
"[<0 4 [3 [2 1]]>]/4".struct("[x]*3").mask("[~ x ~]").scale('D5 dorian').off(1/6, scaleTranspose(-7)).off(1/3, scaleTranspose(-5)).apply(t).tone(instr('lead')).mask("<~ ~ x x>/8"),
|
||||
"<<e3 [~@2 a3]> <[d3 ~] [c3 f3] g3>>".scale('D dorian').apply(sowhat).apply(t).tone(instr('organ')).mask("<x x x ~>/8"),
|
||||
"<[d2 [d2 ~]*3]!3 <a1*2 c2*3 [a1 e2]>>".apply(t).tone(instr('bass')),
|
||||
"c1*6".tone(instr('hihat')),
|
||||
"~ c3".tone(instr('snare')),
|
||||
"<[c1@5 c1] <c1 [[c1@2 c1] ~] [c1 ~ c1] [c1!2 ~ c1!3]>>".tone(instr('kick')),
|
||||
"[2,4]/4".scale('D dorian').apply(t).tone(instr('pad')).mask("<x x x ~>/8")
|
||||
).fast(6/8)`;
|
||||
export const barryHarris = `backgroundImage(
|
||||
'https://media.npr.org/assets/img/2017/02/03/barryharris_600dpi_wide-7eb49998aa1af377d62bb098041624c0a0d1a454.jpg',
|
||||
{style:'background-size:cover'})
|
||||
|
||||
"0,2,[7 6]"
|
||||
.add("<0 1 2 3 4 5 7 8>")
|
||||
.scale('C bebop major')
|
||||
.transpose("<0 1 2 1>/8")
|
||||
.slow(2)
|
||||
.tone((await piano()).toDestination())
|
||||
`;
|
||||
export const blippyRhodes = `const delay = new FeedbackDelay(1/12, .4).chain(vol(0.3), out());
|
||||
|
||||
const drums = await players({
|
||||
bd: 'samples/tidal/bd/BT0A0D0.wav',
|
||||
sn: 'samples/tidal/sn/ST0T0S3.wav',
|
||||
hh: 'samples/tidal/hh/000_hh3closedhh.wav'
|
||||
}, 'https://loophole-letters.vercel.app/')
|
||||
|
||||
const rhodes = await sampler({
|
||||
E1: 'samples/rhodes/MK2Md2000.mp3',
|
||||
E2: 'samples/rhodes/MK2Md2012.mp3',
|
||||
E3: 'samples/rhodes/MK2Md2024.mp3',
|
||||
E4: 'samples/rhodes/MK2Md2036.mp3',
|
||||
E5: 'samples/rhodes/MK2Md2048.mp3',
|
||||
E6: 'samples/rhodes/MK2Md2060.mp3',
|
||||
E7: 'samples/rhodes/MK2Md2072.mp3'
|
||||
}, 'https://loophole-letters.vercel.app/')
|
||||
|
||||
const bass = synth(osc('sawtooth8')).chain(vol(.5),out())
|
||||
const scales = sequence('C major', 'C mixolydian', 'F lydian', ['F minor', slowcat('Db major','Db mixolydian')]).slow(4)
|
||||
|
||||
stack(
|
||||
"<bd sn> <hh hh*2 hh*3>"
|
||||
.tone(drums.chain(out())),
|
||||
"<g4 c5 a4 [ab4 <eb5 f5>]>"
|
||||
.scale(scales)
|
||||
.struct("x*8")
|
||||
.scaleTranspose("0 [-5,-2] -7 [-9,-2]")
|
||||
.legato(.3)
|
||||
.slow(2)
|
||||
.tone(rhodes.chain(vol(0.5).connect(delay), out())),
|
||||
//"<C^7 C7 F^7 [Fm7 <Db^7 Db7>]>".slow(2).voicings().struct("~ x").legato(.25).tone(rhodes),
|
||||
"<c2 c3 f2 [[F2 C2] db2]>"
|
||||
.legato("<1@3 [.3 1]>")
|
||||
.slow(2)
|
||||
.tone(bass),
|
||||
).fast(3/2)`;
|
||||
export const wavyKalimba = `const delay = new FeedbackDelay(1/3, .5).chain(vol(.2), out());
|
||||
let kalimba = await sampler({
|
||||
C5: 'https://freesound.org/data/previews/536/536549_11935698-lq.mp3'
|
||||
})
|
||||
kalimba = kalimba.chain(vol(0.6).connect(delay),out());
|
||||
const scales = sequence('C major', 'C mixolydian', 'F lydian', ['F minor', 'Db major']).slow(4);
|
||||
|
||||
stack(
|
||||
"[0 2 4 6 9 2 0 -2]*3"
|
||||
.add("<0 2>/4")
|
||||
.scale(scales)
|
||||
.struct("x*8")
|
||||
.velocity("<.8 .3 .6>*8")
|
||||
.slow(2)
|
||||
.tone(kalimba),
|
||||
"<c2 c2 f2 [[F2 C2] db2]>"
|
||||
.scale(scales)
|
||||
.scaleTranspose("[0 <2 4>]*2")
|
||||
.struct("x*4")
|
||||
.velocity("<.8 .5>*4")
|
||||
.velocity(0.8)
|
||||
.slow(2)
|
||||
.tone(kalimba)
|
||||
)
|
||||
.legato("<.4 .8 1 1.2 1.4 1.6 1.8 2>/8")
|
||||
.fast(1)`;
|
||||
export const jemblung = `const delay = new FeedbackDelay(1/8, .6).chain(vol(0.15), out());
|
||||
const snare = noise({type:'white',...adsr(0,0.2,0)}).chain(lowpass(5000),vol(1.8),out());
|
||||
const s = polysynth().set({...osc('sawtooth4'),...adsr(0.01,.2,.6,0.2)}).chain(vol(.23).connect(delay),out());
|
||||
stack(
|
||||
stack(
|
||||
"0 1 4 [3!2 5]".edit(
|
||||
// chords
|
||||
x=>x.add("0,3").duration("0.05!3 0.02"),
|
||||
// bass
|
||||
x=>x.add("-8").struct("x*8").duration(0.1)
|
||||
),
|
||||
// melody
|
||||
"12 11*3 12 ~".duration(0.005)
|
||||
)
|
||||
.add("<0 1>")
|
||||
.tune("jemblung2")
|
||||
//.mul(22/5).round().xen("22edo")
|
||||
//.mul(12/5).round().xen("12edo")
|
||||
.tone(s),
|
||||
// kick
|
||||
"[c2 ~]*2".duration(0.05).tone(membrane().chain(out())),
|
||||
// snare
|
||||
"[~ c1]*2".early(0.001).tone(snare),
|
||||
// hihat
|
||||
"c2*8".tone(noise().chain(highpass(6000),vol(0.5).connect(delay),out())),
|
||||
).slow(3)`;
|
||||
export const risingEnemy = `stack(
|
||||
"2,6"
|
||||
.scale('F3 dorian')
|
||||
.transpose(sine2.struct("x*64").slow(4).mul(2).round())
|
||||
.fast(2)
|
||||
.struct("x x*3")
|
||||
.legato(".9 .3"),
|
||||
"0@3 -3*3".legato(".95@3 .4").scale('F2 dorian')
|
||||
)
|
||||
.transpose("<0 1 2 1>/2".early(0.5))
|
||||
.transpose(5)
|
||||
.fast(2 / 3)
|
||||
.tone((await piano()).toDestination())`;
|
||||
export const festivalOfFingers = `const chords = "<Cm7 Fm7 G7 F#7>";
|
||||
stack(
|
||||
chords.voicings().struct("x(3,8,-1)").velocity(.5).off(1/7,x=>x.transpose(12).velocity(.2)),
|
||||
chords.rootNotes(2).struct("x(4,8,-2)"),
|
||||
chords.rootNotes(4)
|
||||
.scale(slowcat('C minor','F dorian','G dorian','F# mixolydian'))
|
||||
.struct("x(3,8,-2)".fast(2))
|
||||
.scaleTranspose("0 4 0 6".early(".125 .5")).layer(scaleTranspose("0,<2 [4,6] [5,7]>/4"))
|
||||
).slow(2)
|
||||
.velocity(sine.struct("x*8").add(3/5).mul(2/5).fast(8))
|
||||
.tone((await piano()).chain(out()))`;
|
||||
export const festivalOfFingers2 = `const chords = "<Cm7 Fm7 G7 F#7 >";
|
||||
const scales = slowcat('C minor','F dorian','G dorian','F# mixolydian')
|
||||
stack(
|
||||
chords.voicings().struct("x(3,8,-1)").velocity(.5).off(1/7,x=>x.transpose(12).velocity(.2)),
|
||||
chords.rootNotes(2).struct("x(4,8)"),
|
||||
chords.rootNotes(4)
|
||||
.scale(scales)
|
||||
.struct("x(3,8,-2)".fast(2))
|
||||
.scaleTranspose("0 4 0 6".early(".125 .5")).layer(scaleTranspose("0,<2 [4,6] [5,7]>/3"))
|
||||
).slow(2).transpose(-1)
|
||||
.legato(cosine.struct("x*8").add(4/5).mul(4/5).fast(8))
|
||||
.velocity(sine.struct("x*8").add(3/5).mul(2/5).fast(8))
|
||||
.tone((await piano()).chain(out())).fast(3/4)`;
|
||||
export const undergroundPlumber = `backgroundImage('https://images.nintendolife.com/news/2016/08/video_exploring_the_funky_inspiration_for_the_super_mario_bros_underground_theme/large.jpg',{ className:'darken' })
|
||||
|
||||
const drums = await players({
|
||||
bd: 'bd/BT0A0D0.wav',
|
||||
sn: 'sn/ST0T0S3.wav',
|
||||
hh: 'hh/000_hh3closedhh.wav',
|
||||
cp: 'cp/HANDCLP0.wav',
|
||||
}, 'https://loophole-letters.vercel.app/samples/tidal/')
|
||||
stack(
|
||||
"<<bd*2 bd> sn> hh".fast(4).slow(2).tone(drums.chain(vol(.5),out())),
|
||||
stack(
|
||||
"[c2 a1 bb1 ~] ~"
|
||||
.stut(2, .6, 1/16)
|
||||
.legato(.4)
|
||||
.slow(2)
|
||||
.tone(synth({...osc('sawtooth7'),...adsr(0,.3,0)}).chain(out())),
|
||||
"[g2,[c3 eb3]]".iter(4)
|
||||
.stutWith(4, 1/8, (x,n)=>x.transpose(n*12).velocity(Math.pow(.4,n)))
|
||||
.legato(.1)
|
||||
)
|
||||
.transpose("<0@2 5 0 7 5 0 -5>/2")
|
||||
|
||||
)
|
||||
.fast(2/3)
|
||||
.pianoroll({minMidi:21,maxMidi:180, background:'transparent',inactive:'#3F8F90',active:'#DE3123'})`;
|
||||
export const bridgeIsOver = `const breaks = (await players({mad:'https://freesound.org/data/previews/22/22274_109943-lq.mp3'})).chain(out())
|
||||
stack(
|
||||
stack(
|
||||
"c3*2 [[c3@1.4 bb2] ab2] gb2*2 <[[gb2@1.4 ab2] bb2] gb2>".legato(".5 1".fast(2)).velocity(.8),
|
||||
"0 ~".scale('c4 whole tone')
|
||||
.euclidLegato(3,8).slow(2).mask("x ~")
|
||||
.stutWith(8, 1/16, (x,n)=>x.scaleTranspose(n).velocity(Math.pow(.7,n)))
|
||||
.scaleTranspose("<0 1 2 3 4 3 2 1>")
|
||||
.fast(2)
|
||||
.velocity(.7)
|
||||
.legato(.5)
|
||||
.stut(3, .5, 1/8)
|
||||
).transpose(-1).tone((await piano()).chain(out())),
|
||||
"mad".slow(2).tone(breaks)
|
||||
).cpm(78).slow(4).pianoroll()
|
||||
`;
|
||||
export const goodTimes = `const scale = slowcat('C3 dorian','Bb2 major').slow(4);
|
||||
stack(
|
||||
"2*4".add(12).scale(scale)
|
||||
.off(1/8,x=>x.scaleTranspose("2")).fast(2)
|
||||
.scaleTranspose("<0 1 2 1>").hush(),
|
||||
"<0 1 2 3>(3,8,2)"
|
||||
.scale(scale)
|
||||
.off(1/4,x=>x.scaleTranspose("2,4")),
|
||||
"<0 4>(5,8)".scale(scale).transpose(-12)
|
||||
)
|
||||
.velocity(".6 .7".fast(4))
|
||||
.legato("2")
|
||||
.scale(scale)
|
||||
.scaleTranspose("<0>".slow(4))
|
||||
.tone((await piano()).chain(out()))
|
||||
//.midi()
|
||||
.velocity(.8)
|
||||
.transpose(5)
|
||||
.slow(2)
|
||||
.pianoroll({maxMidi:100,minMidi:20})`;
|
||||
export const echoPiano = `"<0 2 [4 6](3,4,1) 3*2>"
|
||||
.scale('D minor')
|
||||
.color('salmon')
|
||||
.off(1/4, x=>x.scaleTranspose(2).color('green'))
|
||||
.off(1/2, x=>x.scaleTranspose(6).color('steelblue'))
|
||||
.legato(.5)
|
||||
.echo(4, 1/8, .5)
|
||||
.tone((await piano()).chain(out()))
|
||||
.pianoroll()`;
|
||||
43
docs/dist/ui.js
vendored
43
docs/dist/ui.js
vendored
@ -1,43 +0,0 @@
|
||||
import * as Tone from "../_snowpack/pkg/tone.js";
|
||||
export const hideHeader = () => {
|
||||
document.getElementById("header").style = "display:none";
|
||||
};
|
||||
function frame(callback) {
|
||||
if (window.strudelAnimation) {
|
||||
cancelAnimationFrame(window.strudelAnimation);
|
||||
}
|
||||
const animate = (animationTime) => {
|
||||
const toneTime = Tone.getTransport().seconds;
|
||||
callback(animationTime, toneTime);
|
||||
window.strudelAnimation = requestAnimationFrame(animate);
|
||||
};
|
||||
requestAnimationFrame(animate);
|
||||
}
|
||||
export const backgroundImage = function(src, animateOptions = {}) {
|
||||
const container = document.getElementById("code");
|
||||
const bg = "background-image:url(" + src + ");background-size:contain;";
|
||||
container.style = bg;
|
||||
const {className: initialClassName} = container;
|
||||
const handleOption = (option, value) => {
|
||||
({
|
||||
style: () => container.style = bg + ";" + value,
|
||||
className: () => container.className = value + " " + initialClassName
|
||||
})[option]();
|
||||
};
|
||||
const funcOptions = Object.entries(animateOptions).filter(([_, v]) => typeof v === "function");
|
||||
const stringOptions = Object.entries(animateOptions).filter(([_, v]) => typeof v === "string");
|
||||
stringOptions.forEach(([option, value]) => handleOption(option, value));
|
||||
if (funcOptions.length === 0) {
|
||||
return;
|
||||
}
|
||||
frame((_, t) => funcOptions.forEach(([option, value]) => {
|
||||
handleOption(option, value(t));
|
||||
}));
|
||||
};
|
||||
export const cleanup = () => {
|
||||
const container = document.getElementById("code");
|
||||
if (container) {
|
||||
container.style = "";
|
||||
container.className = "grow relative";
|
||||
}
|
||||
};
|
||||
59
docs/dist/useCycle.js
vendored
59
docs/dist/useCycle.js
vendored
@ -1,59 +0,0 @@
|
||||
import {useEffect, useState} from "../_snowpack/pkg/react.js";
|
||||
import * as Tone from "../_snowpack/pkg/tone.js";
|
||||
import {TimeSpan, State} from "../_snowpack/link/strudel.js";
|
||||
function useCycle(props) {
|
||||
const {onEvent, onQuery, onSchedule, ready = true, onDraw} = props;
|
||||
const [started, setStarted] = useState(false);
|
||||
const cycleDuration = 1;
|
||||
const activeCycle = () => Math.floor(Tone.getTransport().seconds / cycleDuration);
|
||||
const query = (cycle = activeCycle()) => {
|
||||
const timespan = new TimeSpan(cycle, cycle + 1);
|
||||
const events = onQuery?.(new State(timespan)) || [];
|
||||
onSchedule?.(events, cycle);
|
||||
const cancelFrom = timespan.begin.valueOf();
|
||||
Tone.getTransport().cancel(cancelFrom);
|
||||
const queryNextTime = (cycle + 1) * cycleDuration - 0.5;
|
||||
const t = Math.max(Tone.getTransport().seconds, queryNextTime) + 0.1;
|
||||
Tone.getTransport().schedule(() => {
|
||||
query(cycle + 1);
|
||||
}, t);
|
||||
events?.filter((event) => event.part.begin.equals(event.whole.begin)).forEach((event) => {
|
||||
Tone.getTransport().schedule((time) => {
|
||||
const toneEvent = {
|
||||
time: event.whole.begin.valueOf(),
|
||||
duration: event.whole.end.sub(event.whole.begin).valueOf(),
|
||||
value: event.value,
|
||||
context: event.context
|
||||
};
|
||||
onEvent(time, toneEvent);
|
||||
Tone.Draw.schedule(() => {
|
||||
onDraw?.(time, toneEvent);
|
||||
}, time);
|
||||
}, event.part.begin.valueOf());
|
||||
});
|
||||
};
|
||||
useEffect(() => {
|
||||
ready && query();
|
||||
}, [onEvent, onSchedule, onQuery, onDraw, ready]);
|
||||
const start = async () => {
|
||||
setStarted(true);
|
||||
await Tone.start();
|
||||
Tone.getTransport().start("+0.1");
|
||||
};
|
||||
const stop = () => {
|
||||
Tone.getTransport().pause();
|
||||
setStarted(false);
|
||||
};
|
||||
const toggle = () => started ? stop() : start();
|
||||
return {
|
||||
start,
|
||||
stop,
|
||||
onEvent,
|
||||
started,
|
||||
setStarted,
|
||||
toggle,
|
||||
query,
|
||||
activeCycle
|
||||
};
|
||||
}
|
||||
export default useCycle;
|
||||
9
docs/dist/usePostMessage.js
vendored
9
docs/dist/usePostMessage.js
vendored
@ -1,9 +0,0 @@
|
||||
import {useEffect} from "../_snowpack/pkg/react.js";
|
||||
function usePostMessage(listener) {
|
||||
useEffect(() => {
|
||||
window.addEventListener("message", listener);
|
||||
return () => window.removeEventListener("message", listener);
|
||||
}, [listener]);
|
||||
return (data) => window.postMessage(data, "*");
|
||||
}
|
||||
export default usePostMessage;
|
||||
120
docs/dist/useRepl.js
vendored
120
docs/dist/useRepl.js
vendored
@ -1,120 +0,0 @@
|
||||
import {useCallback, useState, useMemo} from "../_snowpack/pkg/react.js";
|
||||
import {getPlayableNoteValue} from "../_snowpack/link/util.js";
|
||||
import {evaluate} from "./evaluate.js";
|
||||
import useCycle from "./useCycle.js";
|
||||
import usePostMessage from "./usePostMessage.js";
|
||||
let s4 = () => {
|
||||
return Math.floor((1 + Math.random()) * 65536).toString(16).substring(1);
|
||||
};
|
||||
function useRepl({tune, defaultSynth, autolink = true, onEvent, onDraw}) {
|
||||
const id = useMemo(() => s4(), []);
|
||||
const [code, setCode] = useState(tune);
|
||||
const [activeCode, setActiveCode] = useState();
|
||||
const [log, setLog] = useState("");
|
||||
const [error, setError] = useState();
|
||||
const [pending, setPending] = useState(false);
|
||||
const [hash, setHash] = useState("");
|
||||
const [pattern, setPattern] = useState();
|
||||
const dirty = code !== activeCode || error;
|
||||
const generateHash = () => encodeURIComponent(btoa(code));
|
||||
const activateCode = async (_code = code) => {
|
||||
if (activeCode && !dirty) {
|
||||
setError(void 0);
|
||||
cycle.start();
|
||||
return;
|
||||
}
|
||||
try {
|
||||
setPending(true);
|
||||
const parsed = await evaluate(_code);
|
||||
cycle.start();
|
||||
broadcast({type: "start", from: id});
|
||||
setPattern(() => parsed.pattern);
|
||||
if (autolink) {
|
||||
window.location.hash = "#" + encodeURIComponent(btoa(code));
|
||||
}
|
||||
setHash(generateHash());
|
||||
setError(void 0);
|
||||
setActiveCode(_code);
|
||||
setPending(false);
|
||||
} catch (err) {
|
||||
err.message = "evaluation error: " + err.message;
|
||||
console.warn(err);
|
||||
setError(err);
|
||||
}
|
||||
};
|
||||
const pushLog = (message) => setLog((log2) => log2 + `${log2 ? "\n\n" : ""}${message}`);
|
||||
const logCycle = (_events, cycle2) => {
|
||||
if (_events.length) {
|
||||
}
|
||||
};
|
||||
onDraw = useMemo(() => {
|
||||
if (activeCode && !activeCode.includes("strudel disable-highlighting")) {
|
||||
return onDraw;
|
||||
}
|
||||
}, [activeCode]);
|
||||
const cycle = useCycle({
|
||||
onDraw,
|
||||
onEvent: useCallback((time, event) => {
|
||||
try {
|
||||
onEvent?.(event);
|
||||
const {onTrigger, velocity} = event.context;
|
||||
if (!onTrigger) {
|
||||
if (defaultSynth) {
|
||||
const note = getPlayableNoteValue(event);
|
||||
defaultSynth.triggerAttackRelease(note, event.duration, time, velocity);
|
||||
} else {
|
||||
throw new Error("no defaultSynth passed to useRepl.");
|
||||
}
|
||||
} else {
|
||||
onTrigger(time, event);
|
||||
}
|
||||
} catch (err) {
|
||||
console.warn(err);
|
||||
err.message = "unplayable event: " + err?.message;
|
||||
pushLog(err.message);
|
||||
}
|
||||
}, [onEvent]),
|
||||
onQuery: useCallback((state) => {
|
||||
try {
|
||||
return pattern?.query(state) || [];
|
||||
} catch (err) {
|
||||
console.warn(err);
|
||||
err.message = "query error: " + err.message;
|
||||
setError(err);
|
||||
return [];
|
||||
}
|
||||
}, [pattern]),
|
||||
onSchedule: useCallback((_events, cycle2) => logCycle(_events, cycle2), [pattern]),
|
||||
ready: !!pattern && !!activeCode
|
||||
});
|
||||
const broadcast = usePostMessage(({data: {from, type}}) => {
|
||||
if (type === "start" && from !== id) {
|
||||
cycle.setStarted(false);
|
||||
setActiveCode(void 0);
|
||||
}
|
||||
});
|
||||
const togglePlay = () => {
|
||||
if (!cycle.started) {
|
||||
activateCode();
|
||||
} else {
|
||||
cycle.stop();
|
||||
}
|
||||
};
|
||||
return {
|
||||
pending,
|
||||
code,
|
||||
setCode,
|
||||
pattern,
|
||||
error,
|
||||
cycle,
|
||||
setPattern,
|
||||
dirty,
|
||||
log,
|
||||
togglePlay,
|
||||
activateCode,
|
||||
activeCode,
|
||||
pushLog,
|
||||
hash
|
||||
};
|
||||
}
|
||||
export default useRepl;
|
||||
34
docs/dist/voicings.js
vendored
34
docs/dist/voicings.js
vendored
@ -1,34 +0,0 @@
|
||||
import {Pattern as _Pattern, stack, Hap, reify} from "../_snowpack/link/strudel.js";
|
||||
import _voicings from "../_snowpack/pkg/chord-voicings.js";
|
||||
const {dictionaryVoicing, minTopNoteDiff, lefthand} = _voicings;
|
||||
const getVoicing = (chord, lastVoicing, range = ["F3", "A4"]) => dictionaryVoicing({
|
||||
chord,
|
||||
dictionary: lefthand,
|
||||
range,
|
||||
picker: minTopNoteDiff,
|
||||
lastVoicing
|
||||
});
|
||||
const Pattern = _Pattern;
|
||||
Pattern.prototype.fmapNested = function(func) {
|
||||
return new Pattern((span) => this.query(span).map((event) => reify(func(event)).query(span).map((hap) => new Hap(event.whole, event.part, hap.value, hap.context))).flat());
|
||||
};
|
||||
Pattern.prototype.voicings = function(range) {
|
||||
let lastVoicing;
|
||||
if (!range?.length) {
|
||||
range = ["F3", "A4"];
|
||||
}
|
||||
return this.fmapNested((event) => {
|
||||
lastVoicing = getVoicing(event.value, lastVoicing, range);
|
||||
return stack(...lastVoicing)._withContext(() => ({
|
||||
locations: event.context.locations || []
|
||||
}));
|
||||
});
|
||||
};
|
||||
Pattern.prototype._rootNotes = function(octave = 2) {
|
||||
return this.fmap((value) => {
|
||||
const [_, root] = value.match(/^([a-gA-G][b#]?).*$/);
|
||||
return root + octave;
|
||||
});
|
||||
};
|
||||
Pattern.prototype.define("voicings", (range, pat) => pat.voicings(range), {composable: true});
|
||||
Pattern.prototype.define("rootNotes", (oct, pat) => pat.rootNotes(oct), {composable: true, patternified: true});
|
||||
52
docs/dist/xen.js
vendored
52
docs/dist/xen.js
vendored
@ -1,52 +0,0 @@
|
||||
import {Pattern} from "../_snowpack/link/strudel.js";
|
||||
import {mod} from "../_snowpack/link/util.js";
|
||||
function edo(name) {
|
||||
if (!/^[1-9]+[0-9]*edo$/.test(name)) {
|
||||
throw new Error('not an edo scale: "' + name + '"');
|
||||
}
|
||||
const [_, divisions] = name.match(/^([1-9]+[0-9]*)edo$/);
|
||||
return Array.from({length: divisions}, (_2, i) => Math.pow(2, i / divisions));
|
||||
}
|
||||
const presets = {
|
||||
"12ji": [1 / 1, 16 / 15, 9 / 8, 6 / 5, 5 / 4, 4 / 3, 45 / 32, 3 / 2, 8 / 5, 5 / 3, 16 / 9, 15 / 8]
|
||||
};
|
||||
function withBase(freq, scale) {
|
||||
return scale.map((r) => r * freq);
|
||||
}
|
||||
const defaultBase = 220;
|
||||
function getXenScale(scale, indices) {
|
||||
if (typeof scale === "string") {
|
||||
if (/^[1-9]+[0-9]*edo$/.test(scale)) {
|
||||
scale = edo(scale);
|
||||
} else if (presets[scale]) {
|
||||
scale = presets[scale];
|
||||
} else {
|
||||
throw new Error('unknown scale name: "' + scale + '"');
|
||||
}
|
||||
}
|
||||
scale = withBase(defaultBase, scale);
|
||||
if (!indices) {
|
||||
return scale;
|
||||
}
|
||||
return scale.filter((_, i) => indices.includes(i));
|
||||
}
|
||||
function xenOffset(xenScale, offset, index = 0) {
|
||||
const i = mod(index + offset, xenScale.length);
|
||||
const oct = Math.floor(offset / xenScale.length);
|
||||
return xenScale[i] * Math.pow(2, oct);
|
||||
}
|
||||
Pattern.prototype._xen = function(scaleNameOrRatios, steps) {
|
||||
return this._asNumber()._withEvent((event) => {
|
||||
const scale = getXenScale(scaleNameOrRatios);
|
||||
steps = steps || scale.length;
|
||||
const frequency = xenOffset(scale, event.value);
|
||||
return event.withValue(() => frequency).setContext({...event.context, type: "frequency"});
|
||||
});
|
||||
};
|
||||
Pattern.prototype.tuning = function(steps) {
|
||||
return this._asNumber()._withEvent((event) => {
|
||||
const frequency = xenOffset(steps, event.value);
|
||||
return event.withValue(() => frequency).setContext({...event.context, type: "frequency"});
|
||||
});
|
||||
};
|
||||
Pattern.prototype.define("xen", (scale, pat) => pat.xen(scale), {composable: true, patternified: true});
|
||||
1242
docs/global.css
1242
docs/global.css
File diff suppressed because it is too large
Load Diff
45
docs/hot.js
45
docs/hot.js
@ -1,45 +0,0 @@
|
||||
// this file can be used to livecode from the comfort of your editor.
|
||||
// just export a pattern from export default
|
||||
// enable hot mode by pressing "toggle hot mode" on the top right of the repl
|
||||
|
||||
import { mini, h } from './dist/parse.js';
|
||||
import { sequence, pure, reify, slowcat, fastcat, cat, stack, silence } from './_snowpack/link/strudel.js';
|
||||
import { gain, filter } from './dist/tone.js';
|
||||
|
||||
export default stack(
|
||||
sequence(
|
||||
mini(
|
||||
'e5 [b4 c5] d5 [c5 b4]',
|
||||
'a4 [a4 c5] e5 [d5 c5]',
|
||||
'b4 [~ c5] d5 e5',
|
||||
'c5 a4 a4 ~',
|
||||
'[~ d5] [~ f5] a5 [g5 f5]',
|
||||
'e5 [~ c5] e5 [d5 c5]',
|
||||
'b4 [b4 c5] d5 e5',
|
||||
'c5 a4 a4 ~'
|
||||
)
|
||||
.synth({
|
||||
oscillator: { type: 'sine' },
|
||||
envelope: { attack: 0.1 },
|
||||
})
|
||||
.rev()
|
||||
),
|
||||
sequence(
|
||||
mini(
|
||||
'e2 e3 e2 e3 e2 e3 e2 e3',
|
||||
'a2 a3 a2 a3 a2 a3 a2 a3',
|
||||
'g#2 g#3 g#2 g#3 e2 e3 e2 e3',
|
||||
'a2 a3 a2 a3 a2 a3 b1 c2',
|
||||
'd2 d3 d2 d3 d2 d3 d2 d3',
|
||||
'c2 c3 c2 c3 c2 c3 c2 c3',
|
||||
'b1 b2 b1 b2 e2 e3 e2 e3',
|
||||
'a1 a2 a1 a2 a1 a2 a1 a2'
|
||||
)
|
||||
.synth({
|
||||
oscillator: { type: 'sawtooth' },
|
||||
envelope: { attack: 0.1 },
|
||||
})
|
||||
.chain(gain(0.7), filter(2000))
|
||||
.rev()
|
||||
)
|
||||
).slow(16);
|
||||
@ -1,16 +1 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="utf-8" />
|
||||
<link rel="icon" href="/favicon.ico" />
|
||||
<link rel="stylesheet" type="text/css" href="/global.css" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1" />
|
||||
<meta name="description" content="Strudel REPL" />
|
||||
<title>Strudel REPL</title>
|
||||
</head>
|
||||
<body>
|
||||
<div id="root"></div>
|
||||
<noscript>You need to enable JavaScript to run this app.</noscript>
|
||||
<script type="module" src="/dist/index.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="/favicon.ico"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Strudel REPL"/><title>Strudel REPL</title><script defer="defer" src="/static/js/main.77e38ada.js"></script><link href="/static/css/main.0d689283.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
|
||||
15
docs/manifest.json
Normal file
15
docs/manifest.json
Normal file
@ -0,0 +1,15 @@
|
||||
{
|
||||
"short_name": "Strudel REPL",
|
||||
"name": "Strudel REPL - Tidal Patterns in JavaScript",
|
||||
"icons": [
|
||||
{
|
||||
"src": "favicon.ico",
|
||||
"sizes": "64x64 32x32 24x24 16x16",
|
||||
"type": "image/x-icon"
|
||||
}
|
||||
],
|
||||
"start_url": ".",
|
||||
"display": "standalone",
|
||||
"theme_color": "#000000",
|
||||
"background_color": "#ffffff"
|
||||
}
|
||||
3
docs/robots.txt
Normal file
3
docs/robots.txt
Normal file
@ -0,0 +1,3 @@
|
||||
# https://www.robotstxt.org/robotstxt.html
|
||||
User-agent: *
|
||||
Disallow:
|
||||
6
docs/static/css/main.0d689283.css
vendored
Normal file
6
docs/static/css/main.0d689283.css
vendored
Normal file
File diff suppressed because one or more lines are too long
1
docs/static/css/main.0d689283.css.map
vendored
Normal file
1
docs/static/css/main.0d689283.css.map
vendored
Normal file
File diff suppressed because one or more lines are too long
2
docs/static/js/787.8f7ec9e0.chunk.js
vendored
Normal file
2
docs/static/js/787.8f7ec9e0.chunk.js
vendored
Normal file
@ -0,0 +1,2 @@
|
||||
"use strict";(self.webpackChunk_strudel_repl=self.webpackChunk_strudel_repl||[]).push([[787],{787:function(e,t,n){n.r(t),n.d(t,{getCLS:function(){return y},getFCP:function(){return g},getFID:function(){return C},getLCP:function(){return P},getTTFB:function(){return D}});var i,r,a,o,u=function(e,t){return{name:e,value:void 0===t?-1:t,delta:0,entries:[],id:"v2-".concat(Date.now(),"-").concat(Math.floor(8999999999999*Math.random())+1e12)}},c=function(e,t){try{if(PerformanceObserver.supportedEntryTypes.includes(e)){if("first-input"===e&&!("PerformanceEventTiming"in self))return;var n=new PerformanceObserver((function(e){return e.getEntries().map(t)}));return n.observe({type:e,buffered:!0}),n}}catch(e){}},f=function(e,t){var n=function n(i){"pagehide"!==i.type&&"hidden"!==document.visibilityState||(e(i),t&&(removeEventListener("visibilitychange",n,!0),removeEventListener("pagehide",n,!0)))};addEventListener("visibilitychange",n,!0),addEventListener("pagehide",n,!0)},s=function(e){addEventListener("pageshow",(function(t){t.persisted&&e(t)}),!0)},m=function(e,t,n){var i;return function(r){t.value>=0&&(r||n)&&(t.delta=t.value-(i||0),(t.delta||void 0===i)&&(i=t.value,e(t)))}},v=-1,p=function(){return"hidden"===document.visibilityState?0:1/0},d=function(){f((function(e){var t=e.timeStamp;v=t}),!0)},l=function(){return v<0&&(v=p(),d(),s((function(){setTimeout((function(){v=p(),d()}),0)}))),{get firstHiddenTime(){return v}}},g=function(e,t){var n,i=l(),r=u("FCP"),a=function(e){"first-contentful-paint"===e.name&&(f&&f.disconnect(),e.startTime<i.firstHiddenTime&&(r.value=e.startTime,r.entries.push(e),n(!0)))},o=window.performance&&performance.getEntriesByName&&performance.getEntriesByName("first-contentful-paint")[0],f=o?null:c("paint",a);(o||f)&&(n=m(e,r,t),o&&a(o),s((function(i){r=u("FCP"),n=m(e,r,t),requestAnimationFrame((function(){requestAnimationFrame((function(){r.value=performance.now()-i.timeStamp,n(!0)}))}))})))},h=!1,T=-1,y=function(e,t){h||(g((function(e){T=e.value})),h=!0);var n,i=function(t){T>-1&&e(t)},r=u("CLS",0),a=0,o=[],v=function(e){if(!e.hadRecentInput){var t=o[0],i=o[o.length-1];a&&e.startTime-i.startTime<1e3&&e.startTime-t.startTime<5e3?(a+=e.value,o.push(e)):(a=e.value,o=[e]),a>r.value&&(r.value=a,r.entries=o,n())}},p=c("layout-shift",v);p&&(n=m(i,r,t),f((function(){p.takeRecords().map(v),n(!0)})),s((function(){a=0,T=-1,r=u("CLS",0),n=m(i,r,t)})))},E={passive:!0,capture:!0},w=new Date,L=function(e,t){i||(i=t,r=e,a=new Date,F(removeEventListener),S())},S=function(){if(r>=0&&r<a-w){var e={entryType:"first-input",name:i.type,target:i.target,cancelable:i.cancelable,startTime:i.timeStamp,processingStart:i.timeStamp+r};o.forEach((function(t){t(e)})),o=[]}},b=function(e){if(e.cancelable){var t=(e.timeStamp>1e12?new Date:performance.now())-e.timeStamp;"pointerdown"==e.type?function(e,t){var n=function(){L(e,t),r()},i=function(){r()},r=function(){removeEventListener("pointerup",n,E),removeEventListener("pointercancel",i,E)};addEventListener("pointerup",n,E),addEventListener("pointercancel",i,E)}(t,e):L(t,e)}},F=function(e){["mousedown","keydown","touchstart","pointerdown"].forEach((function(t){return e(t,b,E)}))},C=function(e,t){var n,a=l(),v=u("FID"),p=function(e){e.startTime<a.firstHiddenTime&&(v.value=e.processingStart-e.startTime,v.entries.push(e),n(!0))},d=c("first-input",p);n=m(e,v,t),d&&f((function(){d.takeRecords().map(p),d.disconnect()}),!0),d&&s((function(){var a;v=u("FID"),n=m(e,v,t),o=[],r=-1,i=null,F(addEventListener),a=p,o.push(a),S()}))},k={},P=function(e,t){var n,i=l(),r=u("LCP"),a=function(e){var t=e.startTime;t<i.firstHiddenTime&&(r.value=t,r.entries.push(e),n())},o=c("largest-contentful-paint",a);if(o){n=m(e,r,t);var v=function(){k[r.id]||(o.takeRecords().map(a),o.disconnect(),k[r.id]=!0,n(!0))};["keydown","click"].forEach((function(e){addEventListener(e,v,{once:!0,capture:!0})})),f(v,!0),s((function(i){r=u("LCP"),n=m(e,r,t),requestAnimationFrame((function(){requestAnimationFrame((function(){r.value=performance.now()-i.timeStamp,k[r.id]=!0,n(!0)}))}))}))}},D=function(e){var t,n=u("TTFB");t=function(){try{var t=performance.getEntriesByType("navigation")[0]||function(){var e=performance.timing,t={entryType:"navigation",startTime:0};for(var n in e)"navigationStart"!==n&&"toJSON"!==n&&(t[n]=Math.max(e[n]-e.navigationStart,0));return t}();if(n.value=n.delta=t.responseStart,n.value<0||n.value>performance.now())return;n.entries=[t],e(n)}catch(e){}},"complete"===document.readyState?setTimeout(t,0):addEventListener("load",(function(){return setTimeout(t,0)}))}}}]);
|
||||
//# sourceMappingURL=787.8f7ec9e0.chunk.js.map
|
||||
1
docs/static/js/787.8f7ec9e0.chunk.js.map
vendored
Normal file
1
docs/static/js/787.8f7ec9e0.chunk.js.map
vendored
Normal file
File diff suppressed because one or more lines are too long
3
docs/static/js/main.77e38ada.js
vendored
Normal file
3
docs/static/js/main.77e38ada.js
vendored
Normal file
File diff suppressed because one or more lines are too long
56
docs/static/js/main.77e38ada.js.LICENSE.txt
vendored
Normal file
56
docs/static/js/main.77e38ada.js.LICENSE.txt
vendored
Normal file
@ -0,0 +1,56 @@
|
||||
/*
|
||||
object-assign
|
||||
(c) Sindre Sorhus
|
||||
@license MIT
|
||||
*/
|
||||
|
||||
/**
|
||||
* @license Fraction.js v4.2.0 05/03/2022
|
||||
* https://www.xarg.org/2014/03/rational-numbers-in-javascript/
|
||||
*
|
||||
* Copyright (c) 2021, Robert Eisele (robert@xarg.org)
|
||||
* Dual licensed under the MIT or GPL Version 2 licenses.
|
||||
**/
|
||||
|
||||
/**
|
||||
* Tone.js
|
||||
* @author Yotam Mann
|
||||
* @license http://opensource.org/licenses/MIT MIT License
|
||||
* @copyright 2014-2019 Yotam Mann
|
||||
*/
|
||||
|
||||
/** @license React v0.20.2
|
||||
* scheduler.production.min.js
|
||||
*
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
/** @license React v17.0.2
|
||||
* react-dom.production.min.js
|
||||
*
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
/** @license React v17.0.2
|
||||
* react-jsx-runtime.production.min.js
|
||||
*
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
/** @license React v17.0.2
|
||||
* react.production.min.js
|
||||
*
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
1
docs/static/js/main.77e38ada.js.map
vendored
Normal file
1
docs/static/js/main.77e38ada.js.map
vendored
Normal file
File diff suppressed because one or more lines are too long
|
Before Width: | Height: | Size: 42 KiB After Width: | Height: | Size: 42 KiB |
95
docs/tutorial/index.097d520a.js
Normal file
95
docs/tutorial/index.097d520a.js
Normal file
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user