@datagouv/components-next 0.2.0 → 1.0.1

package/dist/Event-BOgJUhNR.js

@@ -0,0 +1,738 @@
+import { H as x } from "./View-DcDc7N2K.js";
+import { a as I } from "./common-C4rDcQpp.js";
+import { B as C, a6 as h, ak as m, u as S, l as p, E as N, i as L, a3 as P, I as Z } from "./proj-CKwYjU38.js";
+import { c as T } from "./Image-BN-4XkIn.js";
+const n = {
+  OPACITY: "opacity",
+  VISIBLE: "visible",
+  EXTENT: "extent",
+  Z_INDEX: "zIndex",
+  MAX_RESOLUTION: "maxResolution",
+  MIN_RESOLUTION: "minResolution",
+  MAX_ZOOM: "maxZoom",
+  MIN_ZOOM: "minZoom",
+  SOURCE: "source",
+  MAP: "map"
+};
+class D extends C {
+  /**
+   * @param {Options} options Layer options.
+   */
+  constructor(e) {
+    super(), this.on, this.once, this.un, this.background_ = e.background;
+    const r = Object.assign({}, e);
+    typeof e.properties == "object" && (delete r.properties, Object.assign(r, e.properties)), r[n.OPACITY] = e.opacity !== void 0 ? e.opacity : 1, I(
+      typeof r[n.OPACITY] == "number",
+      "Layer opacity must be a number"
+    ), r[n.VISIBLE] = e.visible !== void 0 ? e.visible : !0, r[n.Z_INDEX] = e.zIndex, r[n.MAX_RESOLUTION] = e.maxResolution !== void 0 ? e.maxResolution : 1 / 0, r[n.MIN_RESOLUTION] = e.minResolution !== void 0 ? e.minResolution : 0, r[n.MIN_ZOOM] = e.minZoom !== void 0 ? e.minZoom : -1 / 0, r[n.MAX_ZOOM] = e.maxZoom !== void 0 ? e.maxZoom : 1 / 0, this.className_ = r.className !== void 0 ? r.className : "ol-layer", delete r.className, this.setProperties(r), this.state_ = null;
+  }
+  /**
+   * Get the background for this layer.
+   * @return {BackgroundColor|false} Layer background.
+   */
+  getBackground() {
+    return this.background_;
+  }
+  /**
+   * @return {string} CSS class name.
+   */
+  getClassName() {
+    return this.className_;
+  }
+  /**
+   * This method is not meant to be called by layers or layer renderers because the state
+   * is incorrect if the layer is included in a layer group.
+   *
+   * @param {boolean} [managed] Layer is managed.
+   * @return {import("./Layer.js").State} Layer state.
+   */
+  getLayerState(e) {
+    const r = this.state_ || /** @type {?} */
+    {
+      layer: this,
+      managed: e === void 0 ? !0 : e
+    }, s = this.getZIndex();
+    return r.opacity = h(Math.round(this.getOpacity() * 100) / 100, 0, 1), r.visible = this.getVisible(), r.extent = this.getExtent(), r.zIndex = s === void 0 && !r.managed ? 1 / 0 : s, r.maxResolution = this.getMaxResolution(), r.minResolution = Math.max(this.getMinResolution(), 0), r.minZoom = this.getMinZoom(), r.maxZoom = this.getMaxZoom(), this.state_ = r, r;
+  }
+  /**
+   * @abstract
+   * @param {Array<import("./Layer.js").default>} [array] Array of layers (to be
+   *     modified in place).
+   * @return {Array<import("./Layer.js").default>} Array of layers.
+   */
+  getLayersArray(e) {
+    return m();
+  }
+  /**
+   * @abstract
+   * @param {Array<import("./Layer.js").State>} [states] Optional list of layer
+   *     states (to be modified in place).
+   * @return {Array<import("./Layer.js").State>} List of layer states.
+   */
+  getLayerStatesArray(e) {
+    return m();
+  }
+  /**
+   * Return the {@link module:ol/extent~Extent extent} of the layer or `undefined` if it
+   * will be visible regardless of extent.
+   * @return {import("../extent.js").Extent|undefined} The layer extent.
+   * @observable
+   * @api
+   */
+  getExtent() {
+    return (
+      /** @type {import("../extent.js").Extent|undefined} */
+      this.get(n.EXTENT)
+    );
+  }
+  /**
+   * Return the maximum resolution of the layer. Returns Infinity if
+   * the layer has no maximum resolution set.
+   * @return {number} The maximum resolution of the layer.
+   * @observable
+   * @api
+   */
+  getMaxResolution() {
+    return (
+      /** @type {number} */
+      this.get(n.MAX_RESOLUTION)
+    );
+  }
+  /**
+   * Return the minimum resolution of the layer. Returns 0 if
+   * the layer has no minimum resolution set.
+   * @return {number} The minimum resolution of the layer.
+   * @observable
+   * @api
+   */
+  getMinResolution() {
+    return (
+      /** @type {number} */
+      this.get(n.MIN_RESOLUTION)
+    );
+  }
+  /**
+   * Return the minimum zoom level of the layer. Returns -Infinity if
+   * the layer has no minimum zoom set.
+   * @return {number} The minimum zoom level of the layer.
+   * @observable
+   * @api
+   */
+  getMinZoom() {
+    return (
+      /** @type {number} */
+      this.get(n.MIN_ZOOM)
+    );
+  }
+  /**
+   * Return the maximum zoom level of the layer. Returns Infinity if
+   * the layer has no maximum zoom set.
+   * @return {number} The maximum zoom level of the layer.
+   * @observable
+   * @api
+   */
+  getMaxZoom() {
+    return (
+      /** @type {number} */
+      this.get(n.MAX_ZOOM)
+    );
+  }
+  /**
+   * Return the opacity of the layer (between 0 and 1).
+   * @return {number} The opacity of the layer.
+   * @observable
+   * @api
+   */
+  getOpacity() {
+    return (
+      /** @type {number} */
+      this.get(n.OPACITY)
+    );
+  }
+  /**
+   * @abstract
+   * @return {import("../source/Source.js").State} Source state.
+   */
+  getSourceState() {
+    return m();
+  }
+  /**
+   * Return the value of this layer's `visible` property. To find out whether the layer
+   * is visible on a map, use `isVisible()` instead.
+   * @return {boolean} The value of the `visible` property of the layer.
+   * @observable
+   * @api
+   */
+  getVisible() {
+    return (
+      /** @type {boolean} */
+      this.get(n.VISIBLE)
+    );
+  }
+  /**
+   * Return the Z-index of the layer, which is used to order layers before
+   * rendering. Returns undefined if the layer is unmanaged.
+   * @return {number|undefined} The Z-index of the layer.
+   * @observable
+   * @api
+   */
+  getZIndex() {
+    return (
+      /** @type {number|undefined} */
+      this.get(n.Z_INDEX)
+    );
+  }
+  /**
+   * Sets the background color.
+   * @param {BackgroundColor} [background] Background color.
+   */
+  setBackground(e) {
+    this.background_ = e, this.changed();
+  }
+  /**
+   * Set the extent at which the layer is visible.  If `undefined`, the layer
+   * will be visible at all extents.
+   * @param {import("../extent.js").Extent|undefined} extent The extent of the layer.
+   * @observable
+   * @api
+   */
+  setExtent(e) {
+    this.set(n.EXTENT, e);
+  }
+  /**
+   * Set the maximum resolution at which the layer is visible.
+   * @param {number} maxResolution The maximum resolution of the layer.
+   * @observable
+   * @api
+   */
+  setMaxResolution(e) {
+    this.set(n.MAX_RESOLUTION, e);
+  }
+  /**
+   * Set the minimum resolution at which the layer is visible.
+   * @param {number} minResolution The minimum resolution of the layer.
+   * @observable
+   * @api
+   */
+  setMinResolution(e) {
+    this.set(n.MIN_RESOLUTION, e);
+  }
+  /**
+   * Set the maximum zoom (exclusive) at which the layer is visible.
+   * Note that the zoom levels for layer visibility are based on the
+   * view zoom level, which may be different from a tile source zoom level.
+   * @param {number} maxZoom The maximum zoom of the layer.
+   * @observable
+   * @api
+   */
+  setMaxZoom(e) {
+    this.set(n.MAX_ZOOM, e);
+  }
+  /**
+   * Set the minimum zoom (inclusive) at which the layer is visible.
+   * Note that the zoom levels for layer visibility are based on the
+   * view zoom level, which may be different from a tile source zoom level.
+   * @param {number} minZoom The minimum zoom of the layer.
+   * @observable
+   * @api
+   */
+  setMinZoom(e) {
+    this.set(n.MIN_ZOOM, e);
+  }
+  /**
+   * Set the opacity of the layer, allowed values range from 0 to 1.
+   * @param {number} opacity The opacity of the layer.
+   * @observable
+   * @api
+   */
+  setOpacity(e) {
+    I(typeof e == "number", "Layer opacity must be a number"), this.set(n.OPACITY, e);
+  }
+  /**
+   * Set the visibility of the layer (`true` or `false`).
+   * @param {boolean} visible The visibility of the layer.
+   * @observable
+   * @api
+   */
+  setVisible(e) {
+    this.set(n.VISIBLE, e);
+  }
+  /**
+   * Set Z-index of the layer, which is used to order layers before rendering.
+   * The default Z-index is 0.
+   * @param {number} zindex The z-index of the layer.
+   * @observable
+   * @api
+   */
+  setZIndex(e) {
+    this.set(n.Z_INDEX, e);
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    this.state_ && (this.state_.layer = null, this.state_ = null), super.disposeInternal();
+  }
+}
+const K = {
+  /**
+   * Triggered before a layer is rendered.
+   * @event module:ol/render/Event~RenderEvent#prerender
+   * @api
+   */
+  PRERENDER: "prerender",
+  /**
+   * Triggered after a layer is rendered.
+   * @event module:ol/render/Event~RenderEvent#postrender
+   * @api
+   */
+  POSTRENDER: "postrender",
+  /**
+   * Triggered before layers are composed.  When dispatched by the map, the event object will not have
+   * a `context` set.  When dispatched by a layer, the event object will have a `context` set.  Only
+   * WebGL layers currently dispatch this event.
+   * @event module:ol/render/Event~RenderEvent#precompose
+   * @api
+   */
+  PRECOMPOSE: "precompose",
+  /**
+   * Triggered after layers are composed.  When dispatched by the map, the event object will not have
+   * a `context` set.  When dispatched by a layer, the event object will have a `context` set.  Only
+   * WebGL layers currently dispatch this event.
+   * @event module:ol/render/Event~RenderEvent#postcompose
+   * @api
+   */
+  POSTCOMPOSE: "postcompose",
+  /**
+   * Triggered when rendering is complete, i.e. all sources and tiles have
+   * finished loading for the current viewport, and all tiles are faded in.
+   * The event object will not have a `context` set.
+   * @event module:ol/render/Event~RenderEvent#rendercomplete
+   * @api
+   */
+  RENDERCOMPLETE: "rendercomplete"
+};
+class G extends D {
+  /**
+   * @param {Options<SourceType>} options Layer options.
+   */
+  constructor(e) {
+    const r = Object.assign({}, e);
+    delete r.source, super(r), this.on, this.once, this.un, this.mapPrecomposeKey_ = null, this.mapRenderKey_ = null, this.sourceChangeKey_ = null, this.renderer_ = null, this.sourceReady_ = !1, this.rendered = !1, e.render && (this.render = e.render), e.map && this.setMap(e.map), this.addChangeListener(
+      n.SOURCE,
+      this.handleSourcePropertyChange_
+    );
+    const s = e.source ? (
+      /** @type {SourceType} */
+      e.source
+    ) : null;
+    this.setSource(s);
+  }
+  /**
+   * @param {Array<import("./Layer.js").default>} [array] Array of layers (to be modified in place).
+   * @return {Array<import("./Layer.js").default>} Array of layers.
+   * @override
+   */
+  getLayersArray(e) {
+    return e = e || [], e.push(this), e;
+  }
+  /**
+   * @param {Array<import("./Layer.js").State>} [states] Optional list of layer states (to be modified in place).
+   * @return {Array<import("./Layer.js").State>} List of layer states.
+   * @override
+   */
+  getLayerStatesArray(e) {
+    return e = e || [], e.push(this.getLayerState()), e;
+  }
+  /**
+   * Get the layer source.
+   * @return {SourceType|null} The layer source (or `null` if not yet set).
+   * @observable
+   * @api
+   */
+  getSource() {
+    return (
+      /** @type {SourceType} */
+      this.get(n.SOURCE) || null
+    );
+  }
+  /**
+   * @return {SourceType|null} The source being rendered.
+   */
+  getRenderSource() {
+    return this.getSource();
+  }
+  /**
+   * @return {import("../source/Source.js").State} Source state.
+   * @override
+   */
+  getSourceState() {
+    const e = this.getSource();
+    return e ? e.getState() : "undefined";
+  }
+  /**
+   * @private
+   */
+  handleSourceChange_() {
+    this.changed(), !(this.sourceReady_ || this.getSource().getState() !== "ready") && (this.sourceReady_ = !0, this.dispatchEvent("sourceready"));
+  }
+  /**
+   * @private
+   */
+  handleSourcePropertyChange_() {
+    this.sourceChangeKey_ && (S(this.sourceChangeKey_), this.sourceChangeKey_ = null), this.sourceReady_ = !1;
+    const e = this.getSource();
+    e && (this.sourceChangeKey_ = p(
+      e,
+      N.CHANGE,
+      this.handleSourceChange_,
+      this
+    ), e.getState() === "ready" && (this.sourceReady_ = !0, setTimeout(() => {
+      this.dispatchEvent("sourceready");
+    }, 0))), this.changed();
+  }
+  /**
+   * @param {import("../pixel").Pixel} pixel Pixel.
+   * @return {Promise<Array<import("../Feature").FeatureLike>>} Promise that resolves with
+   * an array of features.
+   */
+  getFeatures(e) {
+    return this.renderer_ ? this.renderer_.getFeatures(e) : Promise.resolve([]);
+  }
+  /**
+   * @param {import("../pixel").Pixel} pixel Pixel.
+   * @return {Uint8ClampedArray|Uint8Array|Float32Array|DataView|null} Pixel data.
+   */
+  getData(e) {
+    return !this.renderer_ || !this.rendered ? null : this.renderer_.getData(e);
+  }
+  /**
+   * The layer is visible on the map view, i.e. within its min/max resolution or zoom and
+   * extent, not set to `visible: false`, and not inside a layer group that is set
+   * to `visible: false`.
+   * @param {View|import("../View.js").ViewStateLayerStateExtent} [view] View or {@link import("../Map.js").FrameState}.
+   * Only required when the layer is not added to a map.
+   * @return {boolean} The layer is visible in the map view.
+   * @api
+   */
+  isVisible(e) {
+    let r;
+    const s = this.getMapInternal();
+    !e && s && (e = s.getView()), e instanceof x ? r = {
+      viewState: e.getState(),
+      extent: e.calculateExtent()
+    } : r = e, !r.layerStatesArray && s && (r.layerStatesArray = s.getLayerGroup().getLayerStatesArray());
+    let i;
+    if (r.layerStatesArray) {
+      if (i = r.layerStatesArray.find(
+        (o) => o.layer === this
+      ), !i)
+        return !1;
+    } else
+      i = this.getLayerState();
+    const a = this.getExtent();
+    return X(i, r.viewState) && (!a || L(a, r.extent));
+  }
+  /**
+   * Get the attributions of the source of this layer for the given view.
+   * @param {View|import("../View.js").ViewStateLayerStateExtent} [view] View or {@link import("../Map.js").FrameState}.
+   * Only required when the layer is not added to a map.
+   * @return {Array<string>} Attributions for this layer at the given view.
+   * @api
+   */
+  getAttributions(e) {
+    if (!this.isVisible(e))
+      return [];
+    const r = this.getSource()?.getAttributions();
+    if (!r)
+      return [];
+    const s = e instanceof x ? e.getViewStateAndExtent() : e;
+    let i = r(s);
+    return Array.isArray(i) || (i = [i]), i;
+  }
+  /**
+   * In charge to manage the rendering of the layer. One layer type is
+   * bounded with one layer renderer.
+   * @param {?import("../Map.js").FrameState} frameState Frame state.
+   * @param {HTMLElement} target Target which the renderer may (but need not) use
+   * for rendering its content.
+   * @return {HTMLElement|null} The rendered element.
+   */
+  render(e, r) {
+    const s = this.getRenderer();
+    return s.prepareFrame(e) ? (this.rendered = !0, s.renderFrame(e, r)) : null;
+  }
+  /**
+   * Called when a layer is not visible during a map render.
+   */
+  unrender() {
+    this.rendered = !1;
+  }
+  /** @return {string} Declutter */
+  getDeclutter() {
+  }
+  /**
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @param {import("../layer/Layer.js").State} layerState Layer state.
+   */
+  renderDeclutter(e, r) {
+  }
+  /**
+   * When the renderer follows a layout -> render approach, do the final rendering here.
+   * @param {import('../Map.js').FrameState} frameState Frame state
+   */
+  renderDeferred(e) {
+    const r = this.getRenderer();
+    r && r.renderDeferred(e);
+  }
+  /**
+   * For use inside the library only.
+   * @param {import("../Map.js").default|null} map Map.
+   */
+  setMapInternal(e) {
+    e || this.unrender(), this.set(n.MAP, e);
+  }
+  /**
+   * For use inside the library only.
+   * @return {import("../Map.js").default|null} Map.
+   */
+  getMapInternal() {
+    return this.get(n.MAP);
+  }
+  /**
+   * Sets the layer to be rendered on top of other layers on a map. The map will
+   * not manage this layer in its layers collection. This
+   * is useful for temporary layers. To remove an unmanaged layer from the map,
+   * use `#setMap(null)`.
+   *
+   * To add the layer to a map and have it managed by the map, use
+   * {@link module:ol/Map~Map#addLayer} instead.
+   * @param {import("../Map.js").default|null} map Map.
+   * @api
+   */
+  setMap(e) {
+    this.mapPrecomposeKey_ && (S(this.mapPrecomposeKey_), this.mapPrecomposeKey_ = null), e || this.changed(), this.mapRenderKey_ && (S(this.mapRenderKey_), this.mapRenderKey_ = null), e && (this.mapPrecomposeKey_ = p(
+      e,
+      K.PRECOMPOSE,
+      this.handlePrecompose_,
+      this
+    ), this.mapRenderKey_ = p(this, N.CHANGE, e.render, e), this.changed());
+  }
+  /**
+   * @param {import("../events/Event.js").default} renderEvent Render event
+   * @private
+   */
+  handlePrecompose_(e) {
+    const r = (
+      /** @type {import("../render/Event.js").default} */
+      e.frameState.layerStatesArray
+    ), s = this.getLayerState(!1);
+    I(
+      !r.some(
+        (i) => i.layer === s.layer
+      ),
+      "A layer can only be added to the map once. Use either `layer.setMap()` or `map.addLayer()`, not both."
+    ), r.push(s);
+  }
+  /**
+   * Set the layer source.
+   * @param {SourceType|null} source The layer source.
+   * @observable
+   * @api
+   */
+  setSource(e) {
+    this.set(n.SOURCE, e);
+  }
+  /**
+   * Get the renderer for this layer.
+   * @return {RendererType|null} The layer renderer.
+   */
+  getRenderer() {
+    return this.renderer_ || (this.renderer_ = this.createRenderer()), this.renderer_;
+  }
+  /**
+   * @return {boolean} The layer has a renderer.
+   */
+  hasRenderer() {
+    return !!this.renderer_;
+  }
+  /**
+   * Create a renderer for this layer.
+   * @return {RendererType} A layer renderer.
+   * @protected
+   */
+  createRenderer() {
+    return null;
+  }
+  /**
+   * This will clear the renderer so that a new one can be created next time it is needed
+   */
+  clearRenderer() {
+    this.renderer_ && (this.renderer_.dispose(), delete this.renderer_);
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    this.clearRenderer(), this.setSource(null), super.disposeInternal();
+  }
+}
+function X(t, e) {
+  if (!t.visible)
+    return !1;
+  const r = e.resolution;
+  if (r < t.minResolution || r >= t.maxResolution)
+    return !1;
+  const s = e.zoom;
+  return s > t.minZoom && s <= t.maxZoom;
+}
+const U = [NaN, NaN, NaN, 0];
+let _;
+function V() {
+  return _ || (_ = T(1, 1, void 0, {
+    willReadFrequently: !0,
+    desynchronized: !0
+  })), _;
+}
+const B = /^rgba?\(\s*(\d+%?)\s+(\d+%?)\s+(\d+%?)(?:\s*\/\s*(\d+%|\d*\.\d+|[01]))?\s*\)$/i, k = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)(?:\s*,\s*(\d+%|\d*\.\d+|[01]))?\s*\)$/i, w = /^rgba?\(\s*(\d+%)\s*,\s*(\d+%)\s*,\s*(\d+%)(?:\s*,\s*(\d+%|\d*\.\d+|[01]))?\s*\)$/i, z = /^#([\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i;
+function f(t, e) {
+  return t.endsWith("%") ? Number(t.substring(0, t.length - 1)) / e : Number(t);
+}
+function l(t) {
+  throw new Error('failed to parse "' + t + '" as color');
+}
+function A(t) {
+  if (t.toLowerCase().startsWith("rgb")) {
+    const a = t.match(k) || t.match(B) || t.match(w);
+    if (a) {
+      const o = a[4], u = 100 / 255;
+      return [
+        h(f(a[1], u) + 0.5 | 0, 0, 255),
+        h(f(a[2], u) + 0.5 | 0, 0, 255),
+        h(f(a[3], u) + 0.5 | 0, 0, 255),
+        o !== void 0 ? h(f(o, 100), 0, 1) : 1
+      ];
+    }
+    l(t);
+  }
+  if (t.startsWith("#")) {
+    if (z.test(t)) {
+      const a = t.substring(1), o = a.length <= 4 ? 1 : 2, u = [0, 0, 0, 255];
+      for (let c = 0, g = a.length; c < g; c += o) {
+        let y = parseInt(a.substring(c, c + o), 16);
+        o === 1 && (y += y << 4), u[c / o] = y;
+      }
+      return u[3] = u[3] / 255, u;
+    }
+    l(t);
+  }
+  const e = V();
+  e.fillStyle = "#abcdef";
+  let r = e.fillStyle;
+  e.fillStyle = t, e.fillStyle === r && (e.fillStyle = "#fedcba", r = e.fillStyle, e.fillStyle = t, e.fillStyle === r && l(t));
+  const s = e.fillStyle;
+  if (s.startsWith("#") || s.startsWith("rgba"))
+    return A(s);
+  e.clearRect(0, 0, 1, 1), e.fillRect(0, 0, 1, 1);
+  const i = Array.from(e.getImageData(0, 0, 1, 1).data);
+  return i[3] = P(i[3] / 255, 3), i;
+}
+function v(t) {
+  return typeof t == "string" ? t : H(t);
+}
+const F = 1024, d = {};
+let R = 0;
+function J(t) {
+  if (t.length === 4)
+    return t;
+  const e = t.slice();
+  return e[3] = 1, e;
+}
+function E(t) {
+  return t > 31308e-7 ? Math.pow(t, 1 / 2.4) * 269.025 - 14.025 : t * 3294.6;
+}
+function M(t) {
+  return t > 0.2068965 ? Math.pow(t, 3) : (t - 4 / 29) * (108 / 841);
+}
+function O(t) {
+  return t > 10.314724 ? Math.pow((t + 14.025) / 269.025, 2.4) : t / 3294.6;
+}
+function b(t) {
+  return t > 88564e-7 ? Math.pow(t, 1 / 3) : t / (108 / 841) + 4 / 29;
+}
+function Q(t) {
+  const e = O(t[0]), r = O(t[1]), s = O(t[2]), i = b(e * 0.222488403 + r * 0.716873169 + s * 0.06060791), a = 500 * (b(e * 0.452247074 + r * 0.399439023 + s * 0.148375274) - i), o = 200 * (i - b(e * 0.016863605 + r * 0.117638439 + s * 0.865350722)), u = Math.atan2(o, a) * (180 / Math.PI);
+  return [
+    116 * i - 16,
+    Math.sqrt(a * a + o * o),
+    u < 0 ? u + 360 : u,
+    t[3]
+  ];
+}
+function ee(t) {
+  const e = (t[0] + 16) / 116, r = t[1], s = t[2] * Math.PI / 180, i = M(e), a = M(e + r / 500 * Math.cos(s)), o = M(e - r / 200 * Math.sin(s)), u = E(a * 3.021973625 - i * 1.617392459 - o * 0.404875592), c = E(a * -0.943766287 + i * 1.916279586 + o * 0.027607165), g = E(a * 0.069407491 - i * 0.22898585 + o * 1.159737864);
+  return [
+    h(u + 0.5 | 0, 0, 255),
+    h(c + 0.5 | 0, 0, 255),
+    h(g + 0.5 | 0, 0, 255),
+    t[3]
+  ];
+}
+function j(t) {
+  if (t === "none")
+    return U;
+  if (d.hasOwnProperty(t))
+    return d[t];
+  if (R >= F) {
+    let r = 0;
+    for (const s in d)
+      (r++ & 3) === 0 && (delete d[s], --R);
+  }
+  const e = A(t);
+  e.length !== 4 && l(t);
+  for (const r of e)
+    isNaN(r) && l(t);
+  return d[t] = e, ++R, e;
+}
+function te(t) {
+  return Array.isArray(t) ? t : j(t);
+}
+function H(t) {
+  let e = t[0];
+  e != (e | 0) && (e = e + 0.5 | 0);
+  let r = t[1];
+  r != (r | 0) && (r = r + 0.5 | 0);
+  let s = t[2];
+  s != (s | 0) && (s = s + 0.5 | 0);
+  const i = t[3] === void 0 ? 1 : Math.round(t[3] * 1e3) / 1e3;
+  return "rgba(" + e + "," + r + "," + s + "," + i + ")";
+}
+class re extends Z {
+  /**
+   * @param {import("./EventType.js").default} type Type.
+   * @param {import("../transform.js").Transform} [inversePixelTransform] Transform for
+   *     CSS pixels to rendered pixels.
+   * @param {import("../Map.js").FrameState} [frameState] Frame state.
+   * @param {?(CanvasRenderingContext2D|WebGLRenderingContext)} [context] Context.
+   */
+  constructor(e, r, s, i) {
+    super(e), this.inversePixelTransform = r, this.frameState = s, this.context = i;
+  }
+}
+export {
+  D as B,
+  K as E,
+  G as L,
+  U as N,
+  re as R,
+  te as a,
+  v as b,
+  j as f,
+  X as i,
+  ee as l,
+  Q as r,
+  H as t,
+  J as w
+};