@weasel-js/gestures 0.5.0

package/dist/index.js

@@ -0,0 +1,556 @@
+// src/grammar/gestures.ts
+var GESTURE_DESCRIPTORS = [
+  { name: "click", hasTarget: true },
+  { name: "pointerDown", hasTarget: true },
+  { name: "dblTap", hasTarget: true },
+  { name: "drag", hasTarget: true },
+  { name: "wheel", hasTarget: false, arg: { name: "direction", values: ["up", "down", "*"], default: "*" } },
+  { name: "keyDown", hasTarget: false, arg: { name: "key", values: "free" } },
+  { name: "keyUp", hasTarget: false, arg: { name: "key", values: "free" } },
+  { name: "keyHeld", hasTarget: false, arg: { name: "key", values: "free" } },
+  { name: "contextMenu", hasTarget: true },
+  { name: "multiTouchTap", hasTarget: false, arg: { name: "fingers", values: ["2", "3", "4"] } }
+];
+var BY_NAME = new Map(
+  GESTURE_DESCRIPTORS.map((d) => [d.name, d])
+);
+function getGestureDescriptor(name) {
+  const d = BY_NAME.get(name);
+  if (!d) throw new Error(`unknown gesture: ${name}`);
+  return d;
+}
+function isKnownGestureName(name) {
+  return BY_NAME.has(name);
+}
+
+// src/grammar/modifiers.ts
+function mods(...keys) {
+  if (keys.length === 0) return "default";
+  const set = new Set(keys);
+  return [
+    set.has("mod") && "mod",
+    set.has("shift") && "shift",
+    set.has("alt") && "alt"
+  ].filter(Boolean).join("+");
+}
+
+// src/grammar/routeGrammar.ts
+var RESERVED_ID_PREFIXES = /* @__PURE__ */ new Set([
+  "!",
+  "@",
+  "#",
+  "$",
+  "%",
+  "^",
+  "&",
+  "*"
+]);
+var RESERVED_ID_NAMES = /* @__PURE__ */ new Set([
+  "initial",
+  "engaged"
+]);
+var VALID_MOD_NAMES = ["mod", "shift", "alt", "ctrl", "meta"];
+var RESERVED_SIGILS = /* @__PURE__ */ new Set(["!", "@", "#", "$", "%", "^", "&"]);
+var ACTIVE_SIGILS = /* @__PURE__ */ new Set(["+", "?"]);
+var MOD_NAME_SET = new Set(VALID_MOD_NAMES);
+function parseRoute(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("[")) {
+    throw new Error(`invalid route (phase brackets required): ${input}`);
+  }
+  const closeIdx = trimmed.indexOf("]");
+  if (closeIdx < 0) throw new Error(`invalid route (unclosed phase bracket): ${input}`);
+  const phaseListRaw = trimmed.slice(1, closeIdx).trim();
+  const phases = parsePhaseList(phaseListRaw, input);
+  let rest = trimmed.slice(closeIdx + 1).trim();
+  const gestureMatch = /^([A-Za-z]+)/.exec(rest);
+  if (!gestureMatch) throw new Error(`invalid route (no gesture name): ${input}`);
+  const gestureName = gestureMatch[1];
+  if (!isKnownGestureName(gestureName)) {
+    throw new Error(`invalid route (unknown gesture "${gestureName}"): ${input}`);
+  }
+  rest = rest.slice(gestureMatch[0].length).trimStart();
+  const desc = getGestureDescriptor(gestureName);
+  let arg;
+  if (rest.startsWith("(")) {
+    const closeArg = rest.indexOf(")");
+    if (closeArg < 0) throw new Error(`invalid route (unbalanced arg parens): ${input}`);
+    const argRaw = rest.slice(1, closeArg);
+    if (!desc.arg) throw new Error(`invalid route (${gestureName} has no arg): ${input}`);
+    if (argRaw !== "*" && desc.arg.values !== "free" && !desc.arg.values.includes(argRaw)) {
+      throw new Error(`invalid route ("${argRaw}" not in ${desc.arg.values.join("|")}): ${input}`);
+    }
+    arg = argRaw;
+    rest = rest.slice(closeArg + 1).trimStart();
+  } else if (desc.arg) {
+    arg = desc.arg.default ?? "*";
+  }
+  let target;
+  if (rest.startsWith("=>")) {
+    if (!desc.hasTarget) throw new Error(`invalid route (${gestureName} has no target): ${input}`);
+    rest = rest.slice(2).trimStart();
+    const tgtMatch = /^([^\s+?!@#$%^&]+)/.exec(rest);
+    if (!tgtMatch) throw new Error(`invalid route (missing target after "=>"): ${input}`);
+    target = tgtMatch[1];
+    rest = rest.slice(tgtMatch[0].length).trimStart();
+  } else if (desc.hasTarget) {
+    target = "*";
+  }
+  const modifiers = {};
+  while (rest.length > 0) {
+    const ch = rest[0];
+    if (RESERVED_SIGILS.has(ch)) {
+      throw new Error(`invalid route ("${ch}" is reserved for future use): ${input}`);
+    }
+    if (!ACTIVE_SIGILS.has(ch)) {
+      throw new Error(`invalid route (unexpected "${ch}" at "${rest}"): ${input}`);
+    }
+    const sigil = ch;
+    rest = rest.slice(1);
+    const nameMatch = /^([a-z]+)/.exec(rest);
+    if (!nameMatch) throw new Error(`invalid route (sigil "${sigil}" without modifier name): ${input}`);
+    const name = nameMatch[1];
+    if (!MOD_NAME_SET.has(name)) {
+      throw new Error(`invalid route (unknown modifier "${name}"): ${input}`);
+    }
+    if (modifiers[name] !== void 0) {
+      throw new Error(`invalid route (duplicate modifier "${name}"): ${input}`);
+    }
+    modifiers[name] = sigil === "+" ? "required" : "optional";
+    rest = rest.slice(nameMatch[0].length).trimStart();
+  }
+  return { phases, gesture: gestureName, arg, target, modifiers };
+}
+function parsePhaseList(raw, input) {
+  if (raw === "") throw new Error(`invalid route (empty phase list): ${input}`);
+  const tokens = raw.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+  if (tokens.length === 0) throw new Error(`invalid route (empty phase list): ${input}`);
+  return tokens.map((t) => parsePhaseAtom(t, input));
+}
+var VALID_PHASES = /* @__PURE__ */ new Set(["initial", "engaged", "*"]);
+function parsePhaseAtom(raw, input) {
+  const parts = raw.split(":");
+  if (parts.length > 2) {
+    throw new Error(`invalid route (phase atom "${raw}" has multiple ":"): ${input}`);
+  }
+  if (parts.length === 1) {
+    const phase2 = parts[0];
+    if (!VALID_PHASES.has(phase2)) {
+      throw new Error(`invalid route (unknown phase "${phase2}" in "${raw}"): ${input}`);
+    }
+    return { channel: "&", phase: phase2 };
+  }
+  const channel = parts[0];
+  const phase = parts[1];
+  if (channel === "") {
+    throw new Error(`invalid route (empty channel before ":" in "${raw}"): ${input}`);
+  }
+  if (!VALID_PHASES.has(phase)) {
+    throw new Error(`invalid route (unknown phase "${phase}" in "${raw}"): ${input}`);
+  }
+  if (channel !== "&" && channel !== "*") {
+    if (RESERVED_ID_NAMES.has(channel)) {
+      throw new Error(`invalid route (channel "${channel}" is a reserved phase keyword): ${input}`);
+    }
+    if (RESERVED_ID_PREFIXES.has(channel[0])) {
+      throw new Error(`invalid route (channel "${channel}" starts with reserved sigil "${channel[0]}"): ${input}`);
+    }
+  }
+  return { channel, phase };
+}
+function formatPhaseAtom(a) {
+  if (a.channel === "&") return a.phase;
+  return `${a.channel}:${a.phase}`;
+}
+function collapseShiftPairs(routes) {
+  if (routes.length < 2) return [...routes];
+  const parsed = routes.map((r) => ({ raw: r, p: parseRoute(r) }));
+  const consumed = /* @__PURE__ */ new Set();
+  const out = [];
+  for (let i = 0; i < parsed.length; i++) {
+    if (consumed.has(i)) continue;
+    const a = parsed[i];
+    let twinIndex = -1;
+    for (let j = i + 1; j < parsed.length; j++) {
+      if (consumed.has(j)) continue;
+      const b = parsed[j];
+      if (isShiftTwin(a.p, b.p)) {
+        twinIndex = j;
+        break;
+      }
+    }
+    if (twinIndex < 0) {
+      out.push(a.raw);
+      continue;
+    }
+    consumed.add(twinIndex);
+    const folded = {
+      ...a.p,
+      modifiers: { ...withoutShift(a.p.modifiers), shift: "optional" }
+    };
+    out.push(formatRoute(folded));
+  }
+  return out;
+}
+function isShiftTwin(a, b) {
+  if (a.gesture !== b.gesture) return false;
+  if (a.arg !== b.arg) return false;
+  if (a.target !== b.target) return false;
+  if (!samePhases(a.phases, b.phases)) return false;
+  const aShift = a.modifiers.shift;
+  const bShift = b.modifiers.shift;
+  const aHas = aShift === "required";
+  const bHas = bShift === "required";
+  if (!(aHas !== bHas)) return false;
+  if (aShift === "optional" || bShift === "optional") return false;
+  for (const name of VALID_MOD_NAMES) {
+    if (name === "shift") continue;
+    if (a.modifiers[name] !== b.modifiers[name]) return false;
+  }
+  return true;
+}
+function samePhases(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i].channel !== b[i].channel || a[i].phase !== b[i].phase) return false;
+  }
+  return true;
+}
+function withoutShift(m) {
+  const { shift: _shift, ...rest } = m;
+  return rest;
+}
+var MOD_ORDER = ["mod", "shift", "alt", "ctrl", "meta"];
+function formatRoute(r) {
+  const desc = getGestureDescriptor(r.gesture);
+  const phaseStr = `[${r.phases.map(formatPhaseAtom).join(",")}]`;
+  let out = `${phaseStr} ${r.gesture}`;
+  if (desc.arg) {
+    const isDefault = r.arg === void 0 || desc.arg.default !== void 0 && r.arg === desc.arg.default;
+    if (!isDefault) out += `(${r.arg})`;
+  }
+  if (desc.hasTarget && r.target !== void 0 && r.target !== "*") {
+    out += ` => ${r.target}`;
+  }
+  for (const name of MOD_ORDER) {
+    const req = r.modifiers[name];
+    if (req === "required") out += ` +${name}`;
+    else if (req === "optional") out += ` ?${name}`;
+  }
+  return out;
+}
+
+// src/grammar/keyRouteGrammar.ts
+var OPTIONAL_SET = new Set(VALID_MOD_NAMES);
+function parseKeyRoute(input) {
+  const [key, ...mods2] = input.split("?");
+  if (!key) throw new Error(`invalid key route (empty key): ${input}`);
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of mods2) {
+    if (!OPTIONAL_SET.has(m)) throw new Error(`unknown optional modifier "${m}" in ${input}`);
+    if (seen.has(m)) throw new Error(`duplicate optional modifier "${m}" in ${input}`);
+    seen.add(m);
+  }
+  return { key, optionalMods: mods2 };
+}
+function formatKeyRoute(r) {
+  return r.optionalMods.length === 0 ? r.key : `${r.key}?${r.optionalMods.join("?")}`;
+}
+function keyRouteToSpec(r) {
+  const mods2 = {};
+  for (const m of r.optionalMods) mods2[m] = "optional";
+  const spec = { kind: "key", key: r.key };
+  if (Object.keys(mods2).length > 0) spec.mods = mods2;
+  return spec;
+}
+
+// src/grammar/describeRoute.ts
+var MOD_NAMES = {
+  mod: "Mod",
+  shift: "Shift",
+  alt: "Alt",
+  ctrl: "Ctrl",
+  meta: "Meta"
+};
+var MOD_ORDER2 = ["mod", "shift", "alt", "ctrl", "meta"];
+var ROUTE_TERMS = {
+  idle: "Not in the middle of a drag or other synchronous operation.",
+  "mid-gesture": "In the middle of a drag or other synchronous operation."
+};
+var ROUTE_FIELD_DEFINITIONS = {
+  phases: "Which lifecycle stage(s) a channel must be in for this route to fire. `initial` = the channel is idle; `engaged` = the channel is mid-gesture. The channel is the binding's own tool (`&`), any tool (`*`), or a named tool id.",
+  gesture: "The class of input event that triggers this route \u2014 click, drag, double-tap, keyDown/keyUp, wheel, contextMenu, or multiTouchTap.",
+  arg: "Sub-class of the gesture. Direction for wheel (up / down / *), key name for keyDown / keyUp, finger count for multiTouchTap. Other gestures have no arg slot.",
+  target: "Which hit-test result the gesture must land on. `*` matches any target; `empty` matches the empty canvas; otherwise the value names a specific hit-target kind.",
+  modifiers: "Modifier keys the user must hold (`+key`) or may optionally hold (`?key`) for this route to match. Unlisted modifiers must not be held."
+};
+function term(label) {
+  return { kind: "term", label, definition: ROUTE_TERMS[label] };
+}
+function joinAnd(parts) {
+  if (parts.length === 0) return "";
+  if (parts.length === 1) return parts[0];
+  if (parts.length === 2) return `${parts[0]} and ${parts[1]}`;
+  return `${parts.slice(0, -1).join(", ")}, and ${parts[parts.length - 1]}`;
+}
+function partitionModifiers(mods2) {
+  const required = [];
+  const optional = [];
+  for (const name of MOD_ORDER2) {
+    const req = mods2[name];
+    if (req === "required") required.push(MOD_NAMES[name]);
+    else if (req === "optional") optional.push(MOD_NAMES[name]);
+  }
+  return { required, optional };
+}
+function phaseAtomParts({ channel, phase }) {
+  const subject = channel === "&" ? "the tool" : channel === "*" ? "any tool" : `the ${channel} tool`;
+  if (phase === "initial") return [`${subject} is `, term("idle")];
+  if (phase === "engaged") return [`${subject} is `, term("mid-gesture")];
+  return [`${subject} is in any phase`];
+}
+function phasesParts(phases) {
+  if (phases.length === 1) return phaseAtomParts(phases[0]);
+  const out = [];
+  phases.forEach((p, i) => {
+    if (i > 0) out.push(" or ");
+    out.push(...phaseAtomParts(p));
+  });
+  return out;
+}
+function targetClause(target, hasTarget) {
+  if (!hasTarget || target === void 0) return "";
+  if (target === "*") return " anywhere";
+  if (target === "empty") return " on empty canvas";
+  return ` on a ${target}`;
+}
+function actionClause(parsed, required) {
+  const desc = getGestureDescriptor(parsed.gesture);
+  const modPrefix = required.length > 0 ? `${joinAnd(required)}-` : "";
+  const target = targetClause(parsed.target, desc.hasTarget);
+  switch (parsed.gesture) {
+    case "keyDown":
+    case "keyUp":
+    case "keyHeld": {
+      const verb = parsed.gesture === "keyDown" ? "presses" : parsed.gesture === "keyUp" ? "releases" : "holds";
+      const key = parsed.arg ?? "any key";
+      return required.length > 0 ? `the user holds ${joinAnd(required)} and ${verb} ${key}` : `the user ${verb} ${key}`;
+    }
+    case "wheel": {
+      const direction = parsed.arg === "up" ? " up" : parsed.arg === "down" ? " down" : "";
+      return `the user ${modPrefix}scrolls${direction}`;
+    }
+    case "multiTouchTap":
+      return `the user taps with ${parsed.arg ?? "multiple"} fingers`;
+    case "contextMenu":
+      return `the user ${modPrefix}opens the context menu${target}`;
+    case "click":
+      return `the user ${modPrefix}clicks${target}`;
+    case "pointerDown":
+      return `the user ${modPrefix}presses${target}`;
+    case "dblTap":
+      return `the user ${modPrefix}double-taps${target}`;
+    case "drag":
+      return `the user ${modPrefix}drags${target}`;
+  }
+}
+function describeRouteParts(parsed, opts = {}) {
+  const { capitalize = true, period = true } = opts;
+  const { required, optional } = partitionModifiers(parsed.modifiers);
+  const action = actionClause(parsed, required);
+  const optClause = optional.length > 0 ? ` (${joinAnd(optional)} optional)` : "";
+  const parts = [];
+  const head = `fires when ${action}, while `;
+  parts.push(capitalize ? head.charAt(0).toUpperCase() + head.slice(1) : head);
+  parts.push(...phasesParts(parsed.phases));
+  if (optClause) parts.push(optClause);
+  if (period) parts.push(".");
+  return mergeAdjacentStrings(parts);
+}
+function describeRoute(parsed, opts = {}) {
+  return describeRouteParts(parsed, opts).map((p) => typeof p === "string" ? p : p.label).join("");
+}
+function mergeAdjacentStrings(parts) {
+  const out = [];
+  for (const p of parts) {
+    const last = out[out.length - 1];
+    if (typeof p === "string" && typeof last === "string") out[out.length - 1] = last + p;
+    else out.push(p);
+  }
+  return out;
+}
+
+// src/grammar/modifierComboToParsed.ts
+function modifierComboToParsed(key) {
+  if (key === "default") return {};
+  const out = {};
+  for (const part of key.split("+")) {
+    out[part] = "required";
+  }
+  return out;
+}
+function canonicalModifiers(mods2) {
+  return Object.entries(mods2).sort(([a], [b]) => a.localeCompare(b)).map(([name, req]) => `${name}=${req}`).join("&");
+}
+
+// src/ui/match.ts
+function resolveSpecValue(value) {
+  if (value === true) return "required";
+  if (value === "optional") return "optional";
+  return "forbidden";
+}
+function matchModifiers(e, mods2, isMac) {
+  let alt = "forbidden";
+  let ctrl = "forbidden";
+  let meta = "forbidden";
+  let shift = "forbidden";
+  if (mods2) {
+    alt = resolveSpecValue(mods2.alt);
+    shift = resolveSpecValue(mods2.shift);
+    if (mods2.mod !== void 0) {
+      const modReq = resolveSpecValue(mods2.mod);
+      if (isMac) meta = modReq;
+      else ctrl = modReq;
+    } else {
+      meta = resolveSpecValue(mods2.meta);
+      ctrl = resolveSpecValue(mods2.ctrl);
+    }
+  }
+  return checkKey(alt, e.altKey) && checkKey(ctrl, e.ctrlKey) && checkKey(meta, e.metaKey) && checkKey(shift, e.shiftKey);
+}
+function checkKey(req, held) {
+  if (req === "required") return held;
+  if (req === "forbidden") return !held;
+  return true;
+}
+function matchKey(eventKey, specKey) {
+  const lower = eventKey.toLowerCase();
+  if (Array.isArray(specKey)) {
+    return specKey.some((k) => k.toLowerCase() === lower);
+  }
+  return specKey.toLowerCase() === lower;
+}
+function matchTarget(target, specTarget, bodyTarget) {
+  if (specTarget === void 0) return true;
+  if (typeof specTarget === "object" && specTarget !== null && "kindOf" in specTarget && typeof specTarget.kindOf === "function") {
+    return specTarget.kindOf(target, bodyTarget);
+  }
+  if (specTarget === "empty" || specTarget === "selected-body" || specTarget === "unselected-body") {
+    if (bodyTarget === void 0) return false;
+    return bodyTarget === specTarget;
+  }
+  return false;
+}
+function normalizePhase(spec) {
+  if (typeof spec === "string") {
+    return [{ channel: "&", phase: spec }];
+  }
+  return spec;
+}
+function matchPhase(spec, ctx) {
+  if (spec === void 0) return true;
+  const atoms = normalizePhase(spec);
+  if (atoms.length === 0) return true;
+  for (const a of atoms) {
+    if (matchPhaseAtom(a, ctx)) return true;
+  }
+  return false;
+}
+function matchPhaseAtom(a, ctx) {
+  if (a.channel === "*") {
+    if (a.phase === "*") return true;
+    const anyEngaged = ctx.engagedChannels.size > 0;
+    return a.phase === "engaged" ? anyEngaged : !anyEngaged;
+  }
+  const id = a.channel === "&" ? ctx.selfChannel : a.channel;
+  if (id == null) return false;
+  if (a.phase === "*") return true;
+  const isEngaged = ctx.engagedChannels.has(id);
+  return a.phase === "engaged" ? isEngaged : !isEngaged;
+}
+function mimeMatchesGlob(mime, glob) {
+  const m = mime.toLowerCase();
+  const g = glob.toLowerCase();
+  if (g === "*" || g === "*/*") return true;
+  if (g.endsWith("/*")) return m.startsWith(g.slice(0, -1));
+  return m === g;
+}
+function matchIngestTypes(items, types) {
+  if (!types || types.length === 0) return true;
+  return items.some((it) => types.some((g) => mimeMatchesGlob(it.mime, g)));
+}
+function matchSpec(e, spec, isMac, phaseCtx) {
+  if (spec.phase !== void 0) {
+    const ctx = phaseCtx ?? { selfChannel: null, engagedChannels: EMPTY_ENGAGED };
+    if (!matchPhase(spec.phase, ctx)) return false;
+  }
+  switch (spec.kind) {
+    case "key": {
+      if (e.kind !== "key") return false;
+      if (!matchKey(e.key, spec.key)) return false;
+      return matchModifiers(e, spec.mods, isMac);
+    }
+    case "key-held": {
+      if (e.kind !== "key-held") return false;
+      if (e.phase !== "down") return false;
+      if (!matchKey(e.key, spec.key)) return false;
+      return matchModifiers(e, spec.mods, isMac);
+    }
+    case "wheel": {
+      if (e.kind !== "wheel") return false;
+      if (!matchModifiers(e, spec.mods, isMac)) return false;
+      const direction = spec.direction ?? "*";
+      if (direction === "up" && !(e.deltaY < 0)) return false;
+      if (direction === "down" && !(e.deltaY > 0)) return false;
+      return true;
+    }
+    case "click": {
+      if (e.kind !== "click") return false;
+      if (!matchModifiers(e, spec.mods, isMac)) return false;
+      return matchTarget(e.target, spec.target, e.bodyTarget);
+    }
+    case "doubleClick": {
+      if (e.kind !== "doubleclick") return false;
+      if (!matchModifiers(e, spec.mods, isMac)) return false;
+      return matchTarget(e.target, spec.target, e.bodyTarget);
+    }
+    case "contextMenu": {
+      if (e.kind !== "contextmenu") return false;
+      if (!matchModifiers(e, spec.mods, isMac)) return false;
+      return matchTarget(e.target, spec.target, e.bodyTarget);
+    }
+    case "drag": {
+      if (e.kind !== "pointerdown") return false;
+      if (!matchModifiers(e, spec.mods, isMac)) return false;
+      return matchTarget(e.affordance, spec.target, e.bodyTarget);
+    }
+    case "multiTouch": {
+      if (e.kind !== "multitouch") return false;
+      if (e.fingers !== spec.fingers) return false;
+      return matchModifiers(e, spec.mods, isMac);
+    }
+    case "multiTouchTap": {
+      if (e.kind !== "multitouchtap") return false;
+      if (e.fingers !== spec.fingers) return false;
+      return matchModifiers(e, spec.mods, isMac);
+    }
+    case "drop": {
+      if (e.kind !== "drop") return false;
+      if (!matchIngestTypes(e.items, spec.types)) return false;
+      return matchModifiers(e, spec.mods, isMac);
+    }
+    case "paste": {
+      if (e.kind !== "paste") return false;
+      if (!matchIngestTypes(e.items, spec.types)) return false;
+      return matchModifiers(e, spec.mods, isMac);
+    }
+    default: {
+      return false;
+    }
+  }
+}
+var EMPTY_ENGAGED = /* @__PURE__ */ new Set();
+
+export { ACTIVE_SIGILS, GESTURE_DESCRIPTORS, MOD_NAME_SET, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, RESERVED_SIGILS, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, VALID_MOD_NAMES, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, formatKeyRoute, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, keyRouteToSpec, matchIngestTypes, matchKey, matchModifiers, matchPhase, matchSpec, matchTarget, mimeMatchesGlob, modifierComboToParsed, mods, parseKeyRoute, parseRoute };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map