gisviewer-vue3-arcgis 1.0.280 → 1.0.282

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/renderer/canvas/Layer.mjs

@@ -0,0 +1,211 @@
+import { equals as y } from "../../array.mjs";
+import { asArray as p } from "../../color.mjs";
+import { isCanvas as C, createMockDiv as T, createCanvasContext2D as R } from "../../dom.mjs";
+import { getTopLeft as E, getTopRight as P, getBottomRight as _, getBottomLeft as w, getWidth as D, getHeight as L } from "../../extent.mjs";
+import { WORKER_OFFSCREEN_CANVAS as M } from "../../has.mjs";
+import N from "../../render/Event.mjs";
+import u from "../../render/EventType.mjs";
+import I from "../../render/canvas/ZIndexContext.mjs";
+import { create as f, equivalent as b, apply as d, compose as m, makeInverse as k, toString as B } from "../../transform.mjs";
+import O from "../Layer.mjs";
+const J = [];
+let c = null;
+function q() {
+  c = R(1, 1, void 0, {
+    willReadFrequently: !0
+  });
+}
+class A extends O {
+  /**
+   * @param {LayerType} layer Layer.
+   */
+  constructor(e) {
+    super(e), this.container = null, this.renderedResolution, this.tempTransform = f(), this.pixelTransform = f(), this.inversePixelTransform = f(), this.context = null, this.deferredContext_ = null, this.containerReused = !1, this.frameState = null;
+  }
+  /**
+   * @param {import('../../DataTile.js').ImageLike} image Image.
+   * @param {number} col The column index.
+   * @param {number} row The row index.
+   * @return {Uint8ClampedArray|null} The image data.
+   */
+  getImageData(e, n, t) {
+    c || q(), c.clearRect(0, 0, 1, 1);
+    let s;
+    try {
+      c.drawImage(e, n, t, 1, 1, 0, 0, 1, 1), s = c.getImageData(0, 0, 1, 1).data;
+    } catch {
+      return c = null, null;
+    }
+    return s;
+  }
+  /**
+   * @param {import('../../Map.js').FrameState} frameState Frame state.
+   * @return {string} Background color.
+   */
+  getBackground(e) {
+    let t = this.getLayer().getBackground();
+    return typeof t == "function" && (t = t(e.viewState.resolution)), t || void 0;
+  }
+  /**
+   * Get a rendering container from an existing target, if compatible.
+   * @param {HTMLElement} target Potential render target.
+   * @param {string} transform CSS transform matrix.
+   * @param {string} [backgroundColor] Background color.
+   */
+  useContainer(e, n, t) {
+    const s = this.getLayer().getClassName();
+    let i, o;
+    if (e && e.className === s && (!t || e && e.style.backgroundColor && y(
+      p(e.style.backgroundColor),
+      p(t)
+    ))) {
+      const r = e.firstElementChild;
+      C(r) && (o = r.getContext("2d"));
+    }
+    if (o && b(o.canvas.style.transform, n) ? (this.container = e, this.context = o, this.containerReused = !0) : this.containerReused ? (this.container = null, this.context = null, this.containerReused = !1) : this.container && (this.container.style.backgroundColor = null), !this.container) {
+      i = M ? T() : document.createElement("div"), i.className = s;
+      let r = i.style;
+      r.position = "absolute", r.width = "100%", r.height = "100%", o = R();
+      const a = (
+        /** @type {HTMLCanvasElement} */
+        o.canvas
+      );
+      i.appendChild(a), r = a.style, r.position = "absolute", r.left = "0", r.transformOrigin = "top left", this.container = i, this.context = o;
+    }
+    !this.containerReused && t && !this.container.style.backgroundColor && (this.container.style.backgroundColor = t);
+  }
+  /**
+   * @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} context Context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {import("../../extent.js").Extent} extent Clip extent.
+   * @protected
+   */
+  clipUnrotated(e, n, t) {
+    const s = E(t), i = P(t), o = _(t), r = w(t);
+    d(n.coordinateToPixelTransform, s), d(n.coordinateToPixelTransform, i), d(n.coordinateToPixelTransform, o), d(n.coordinateToPixelTransform, r);
+    const a = this.inversePixelTransform;
+    d(a, s), d(a, i), d(a, o), d(a, r), e.save(), e.beginPath(), e.moveTo(Math.round(s[0]), Math.round(s[1])), e.lineTo(Math.round(i[0]), Math.round(i[1])), e.lineTo(Math.round(o[0]), Math.round(o[1])), e.lineTo(Math.round(r[0]), Math.round(r[1])), e.clip();
+  }
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {HTMLElement} target Target that may be used to render content to.
+   * @protected
+   */
+  prepareContainer(e, n) {
+    const t = e.extent, s = e.viewState.resolution, i = e.viewState.rotation, o = e.pixelRatio, r = Math.round(D(t) / s * o), a = Math.round(L(t) / s * o);
+    m(
+      this.pixelTransform,
+      e.size[0] / 2,
+      e.size[1] / 2,
+      1 / o,
+      1 / o,
+      i,
+      -r / 2,
+      -a / 2
+    ), k(this.inversePixelTransform, this.pixelTransform);
+    const h = B(this.pixelTransform);
+    if (this.useContainer(n, h, this.getBackground(e)), !this.containerReused) {
+      const l = this.context.canvas;
+      l.width != r || l.height != a ? (l.width = r, l.height = a) : this.context.clearRect(0, 0, r, a), h !== /** @type {HTMLCanvasElement} */
+      l.style.transform && (l.style.transform = h);
+    }
+  }
+  /**
+   * @param {import("../../render/EventType.js").default} type Event type.
+   * @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} context Context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @private
+   */
+  dispatchRenderEvent_(e, n, t) {
+    const s = this.getLayer();
+    if (s.hasListener(e)) {
+      const i = new N(
+        e,
+        this.inversePixelTransform,
+        t,
+        n
+      );
+      s.dispatchEvent(i);
+    }
+  }
+  /**
+   * @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} context Context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @protected
+   */
+  preRender(e, n) {
+    this.frameState = n, !n.declutter && this.dispatchRenderEvent_(u.PRERENDER, e, n);
+  }
+  /**
+   * @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} context Context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @protected
+   */
+  postRender(e, n) {
+    n.declutter || this.dispatchRenderEvent_(u.POSTRENDER, e, n);
+  }
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   */
+  renderDeferredInternal(e) {
+  }
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {import('../../render/canvas/ZIndexContext.js').ZIndexContextProxy} Context.
+   */
+  getRenderContext(e) {
+    return e.declutter && !this.deferredContext_ && (this.deferredContext_ = new I()), e.declutter ? this.deferredContext_.getContext() : this.context;
+  }
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @override
+   */
+  renderDeferred(e) {
+    e.declutter && (this.dispatchRenderEvent_(
+      u.PRERENDER,
+      this.context,
+      e
+    ), e.declutter && this.deferredContext_ && (this.deferredContext_.draw(this.context), this.deferredContext_.clear()), this.renderDeferredInternal(e), this.dispatchRenderEvent_(
+      u.POSTRENDER,
+      this.context,
+      e
+    ));
+  }
+  /**
+   * Creates a transform for rendering to an element that will be rotated after rendering.
+   * @param {import("../../coordinate.js").Coordinate} center Center.
+   * @param {number} resolution Resolution.
+   * @param {number} rotation Rotation.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {number} width Width of the rendered element (in pixels).
+   * @param {number} height Height of the rendered element (in pixels).
+   * @param {number} offsetX Offset on the x-axis in view coordinates.
+   * @protected
+   * @return {!import("../../transform.js").Transform} Transform.
+   */
+  getRenderTransform(e, n, t, s, i, o, r) {
+    const a = i / 2, h = o / 2, l = s / n, x = -l, v = -e[0] + r, g = -e[1];
+    return m(
+      this.tempTransform,
+      a,
+      h,
+      l,
+      x,
+      -t,
+      v,
+      g
+    );
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    delete this.frameState, super.disposeInternal();
+  }
+}
+const Q = A;
+export {
+  J as canvasPool,
+  Q as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/renderer/canvas/TileLayer.mjs

@@ -0,0 +1,490 @@
+import ce, { asImageLike as le } from "../../DataTile.mjs";
+import ye from "../../ImageTile.mjs";
+import Ce from "../../TileRange.mjs";
+import F from "../../TileState.mjs";
+import { ascending as Re } from "../../array.mjs";
+import { createEmpty as me, containsCoordinate as ve, getRotatedViewport as _e, getIntersection as $, getTopLeft as Se, intersects as we, equals as Ee } from "../../extent.mjs";
+import { equivalent as Ke, fromUserExtent as H } from "../../proj.mjs";
+import je from "../../reproj/Tile.mjs";
+import { toSize as Pe } from "../../size.mjs";
+import ae from "../../structs/LRUCache.mjs";
+import { createOrUpdate as de, getCacheKey as V } from "../../tilecoord.mjs";
+import { apply as he, compose as Le } from "../../transform.mjs";
+import { getUid as z } from "../../util.mjs";
+import Fe from "./Layer.mjs";
+function W(R, e, t) {
+  if (!(t in R))
+    return R[t] = /* @__PURE__ */ new Set([e]), !0;
+  const i = R[t], o = i.has(e);
+  return o || i.add(e), !o;
+}
+function Me(R, e, t) {
+  const i = R[t];
+  return i ? i.delete(e) : !1;
+}
+function ue(R, e) {
+  const t = R.layerStatesArray[R.layerIndex];
+  t.extent && (e = $(
+    e,
+    H(t.extent, R.viewState.projection)
+  ));
+  const i = (
+    /** @type {import("../../source/Tile.js").default} */
+    t.layer.getRenderSource()
+  );
+  if (!i.getWrapX()) {
+    const o = i.getTileGridForProjection(R.viewState.projection).getExtent();
+    o && (e = $(e, o));
+  }
+  return e;
+}
+class Ae extends Fe {
+  /**
+   * @param {LayerType} tileLayer Tile layer.
+   * @param {Options} [options] Options.
+   */
+  constructor(e, t) {
+    super(e), t = t || {}, this.extentChanged = !0, this.renderComplete = !1, this.renderedExtent_ = null, this.renderedPixelRatio, this.renderedProjection = null, this.renderedTiles = [], this.renderedSourceKey_, this.renderedSourceRevision_, this.tempExtent = me(), this.tempTileRange_ = new Ce(0, 0, 0, 0), this.tempTileCoord_ = de(0, 0, 0);
+    const i = t.cacheSize !== void 0 ? t.cacheSize : 512;
+    this.tileCache_ = new ae(i), this.sourceTileCache_ = null, this.maxStaleKeys = i * 0.5;
+  }
+  /**
+   * @return {LRUCache} Tile cache.
+   */
+  getTileCache() {
+    return this.tileCache_;
+  }
+  /**
+   * @return {LRUCache} Tile cache.
+   */
+  getSourceTileCache() {
+    return this.sourceTileCache_ || (this.sourceTileCache_ = new ae(512)), this.sourceTileCache_;
+  }
+  /**
+   * Get a tile from the cache or create one if needed.
+   *
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {import("../../Tile.js").default|null} Tile (or null if outside source extent).
+   * @protected
+   */
+  getOrCreateTile(e, t, i, o) {
+    const a = this.tileCache_, s = this.getLayer().getSource(), c = V(s, s.getKey(), e, t, i);
+    let r;
+    if (a.containsKey(c))
+      r = a.get(c);
+    else {
+      const n = o.viewState.projection, l = s.getProjection();
+      if (r = s.getTile(
+        e,
+        t,
+        i,
+        o.pixelRatio,
+        n,
+        !l || Ke(l, n) ? void 0 : this.getSourceTileCache()
+      ), !r)
+        return null;
+      a.set(c, r);
+    }
+    return r;
+  }
+  /**
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {import("../../Tile.js").default|null} Tile (or null if outside source extent).
+   * @protected
+   */
+  getTile(e, t, i, o) {
+    const a = this.getOrCreateTile(e, t, i, o);
+    return a || null;
+  }
+  /**
+   * @param {import("../../pixel.js").Pixel} pixel Pixel.
+   * @return {Uint8ClampedArray} Data at the pixel location.
+   * @override
+   */
+  getData(e) {
+    const t = this.frameState;
+    if (!t)
+      return null;
+    const i = this.getLayer(), o = he(
+      t.pixelToCoordinateTransform,
+      e.slice()
+    ), a = i.getExtent();
+    if (a && !ve(a, o))
+      return null;
+    const u = t.viewState, s = i.getRenderSource(), c = s.getTileGridForProjection(u.projection), r = s.getTilePixelRatio(t.pixelRatio);
+    for (let n = c.getZForResolution(u.resolution); n >= c.getMinZoom(); --n) {
+      const l = c.getTileCoordForCoordAndZ(o, n), d = this.getTile(n, l[1], l[2], t);
+      if (!d || d.getState() !== F.LOADED)
+        continue;
+      const g = c.getOrigin(n), T = Pe(c.getTileSize(n)), w = c.getResolution(n);
+      let h;
+      if (d instanceof ye || d instanceof je)
+        h = d.getImage();
+      else if (d instanceof ce) {
+        if (h = le(d.getData()), !h)
+          continue;
+      } else
+        continue;
+      const v = Math.floor(
+        r * ((o[0] - g[0]) / w - l[1] * T[0])
+      ), M = Math.floor(
+        r * ((g[1] - o[1]) / w - l[2] * T[1])
+      ), m = Math.round(
+        r * s.getGutterForProjection(u.projection)
+      );
+      return this.getImageData(h, v + m, M + m);
+    }
+    return null;
+  }
+  /**
+   * Determine whether render should be called.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {boolean} Layer is ready to be rendered.
+   * @override
+   */
+  prepareFrame(e) {
+    var o;
+    this.renderedProjection ? e.viewState.projection !== this.renderedProjection && (this.tileCache_.clear(), this.renderedProjection = e.viewState.projection) : this.renderedProjection = e.viewState.projection;
+    const t = this.getLayer().getSource();
+    if (!t)
+      return !1;
+    const i = t.getRevision();
+    return this.renderedSourceRevision_ ? this.renderedSourceRevision_ !== i && (this.renderedSourceRevision_ = i, this.renderedSourceKey_ === t.getKey() && (this.tileCache_.clear(), (o = this.sourceTileCache_) == null || o.clear())) : this.renderedSourceRevision_ = i, !0;
+  }
+  /**
+   * Determine whether tiles for next extent should be enqueued for rendering.
+   * @return {boolean} Rendering tiles for next extent is supported.
+   * @protected
+   */
+  enqueueTilesForNextExtent() {
+    return !0;
+  }
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {import("../../extent.js").Extent} extent The extent to be rendered.
+   * @param {number} initialZ The zoom level.
+   * @param {TileLookup} tilesByZ Lookup of tiles by zoom level.
+   * @param {number} preload Number of additional levels to load.
+   */
+  enqueueTiles(e, t, i, o, a) {
+    const u = e.viewState, s = this.getLayer(), c = s.getRenderSource(), r = c.getTileGridForProjection(u.projection), n = z(c);
+    n in e.wantedTiles || (e.wantedTiles[n] = {});
+    const l = e.wantedTiles[n], d = s.getMapInternal(), g = Math.max(
+      i - a,
+      r.getMinZoom(),
+      r.getZForResolution(
+        Math.min(
+          s.getMaxResolution(),
+          d ? d.getView().getResolutionForZoom(Math.max(s.getMinZoom(), 0)) : r.getResolution(0)
+        ),
+        c.zDirection
+      )
+    ), T = u.rotation, w = T ? _e(
+      u.center,
+      u.resolution,
+      T,
+      e.size
+    ) : void 0;
+    for (let h = i; h >= g; --h) {
+      const v = r.getTileRangeForExtentAndZ(
+        t,
+        h,
+        this.tempTileRange_
+      ), M = r.getResolution(h);
+      for (let m = v.minX; m <= v.maxX; ++m)
+        for (let E = v.minY; E <= v.maxY; ++E) {
+          if (T && !r.tileCoordIntersectsViewport([h, m, E], w))
+            continue;
+          const K = this.getTile(h, m, E, e);
+          if (!K || !W(o, K, h))
+            continue;
+          const f = K.getKey();
+          if (l[f] = !0, K.getState() === F.IDLE && !e.tileQueue.isKeyQueued(f)) {
+            const Z = de(h, m, E, this.tempTileCoord_);
+            e.tileQueue.enqueue([
+              K,
+              n,
+              r.getTileCoordCenter(Z),
+              M
+            ]);
+          }
+        }
+    }
+  }
+  /**
+   * Look for tiles covering the provided tile coordinate at an alternate
+   * zoom level.  Loaded tiles will be added to the provided tile texture lookup.
+   * @param {import("../../tilecoord.js").TileCoord} tileCoord The target tile coordinate.
+   * @param {TileLookup} tilesByZ Lookup of tiles by zoom level.
+   * @return {boolean} The tile coordinate is covered by loaded tiles at the alternate zoom level.
+   * @private
+   */
+  findStaleTile_(e, t) {
+    const i = this.tileCache_, o = e[0], a = e[1], u = e[2], s = this.getStaleKeys();
+    for (let c = 0; c < s.length; ++c) {
+      const r = V(
+        this.getLayer().getSource(),
+        s[c],
+        o,
+        a,
+        u
+      );
+      if (i.containsKey(r)) {
+        const n = i.peek(r);
+        if (n.getState() === F.LOADED)
+          return n.endTransition(z(this)), W(t, n, o), !0;
+      }
+    }
+    return !1;
+  }
+  /**
+   * Look for tiles covering the provided tile coordinate at an alternate
+   * zoom level.  Loaded tiles will be added to the provided tile texture lookup.
+   * @param {import("../../tilegrid/TileGrid.js").default} tileGrid The tile grid.
+   * @param {import("../../tilecoord.js").TileCoord} tileCoord The target tile coordinate.
+   * @param {number} altZ The alternate zoom level.
+   * @param {TileLookup} tilesByZ Lookup of tiles by zoom level.
+   * @return {boolean} The tile coordinate is covered by loaded tiles at the alternate zoom level.
+   * @private
+   */
+  findAltTiles_(e, t, i, o) {
+    const a = e.getTileRangeForTileCoordAndZ(
+      t,
+      i,
+      this.tempTileRange_
+    );
+    if (!a)
+      return !1;
+    let u = !0;
+    const s = this.tileCache_, c = this.getLayer().getRenderSource(), r = c.getKey();
+    for (let n = a.minX; n <= a.maxX; ++n)
+      for (let l = a.minY; l <= a.maxY; ++l) {
+        const d = V(c, r, i, n, l);
+        let g = !1;
+        if (s.containsKey(d)) {
+          const T = s.peek(d);
+          T.getState() === F.LOADED && (W(o, T, i), g = !0);
+        }
+        g || (u = !1);
+      }
+    return u;
+  }
+  /**
+   * Render the layer.
+   *
+   * The frame rendering logic has three parts:
+   *
+   *  1. Enqueue tiles
+   *  2. Find alt tiles for those that are not yet loaded
+   *  3. Render loaded tiles
+   *
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {HTMLElement} target Target that may be used to render content to.
+   * @return {HTMLElement} The rendered element.
+   * @override
+   */
+  renderFrame(e, t) {
+    this.renderComplete = !0;
+    const i = e.layerStatesArray[e.layerIndex], o = e.viewState, a = o.projection, u = o.resolution, s = o.center, c = e.pixelRatio, r = this.getLayer(), n = r.getSource(), l = n.getTileGridForProjection(a), d = l.getZForResolution(u, n.zDirection), g = l.getResolution(d), T = n.getKey();
+    this.renderedSourceKey_ ? this.renderedSourceKey_ !== T && (this.prependStaleKey(this.renderedSourceKey_), this.renderedSourceKey_ = T) : this.renderedSourceKey_ = T;
+    let w = e.extent;
+    const h = n.getTilePixelRatio(c);
+    this.prepareContainer(e, t);
+    const v = this.context.canvas.width, M = this.context.canvas.height, m = i.extent && H(i.extent);
+    m && (w = $(
+      w,
+      H(i.extent)
+    ));
+    const E = g * v / 2 / h, K = g * M / 2 / h, A = [
+      s[0] - E,
+      s[1] - K,
+      s[0] + E,
+      s[1] + K
+    ], f = {};
+    this.renderedTiles.length = 0;
+    const Z = r.getPreload();
+    if (e.nextExtent && this.enqueueTilesForNextExtent()) {
+      const x = l.getZForResolution(
+        o.nextResolution,
+        n.zDirection
+      ), y = ue(e, e.nextExtent);
+      this.enqueueTiles(e, y, x, f, Z);
+    }
+    const J = ue(e, w);
+    if (this.enqueueTiles(e, J, d, f, 0), Z > 0 && setTimeout(() => {
+      this.enqueueTiles(
+        e,
+        J,
+        d - 1,
+        f,
+        Z - 1
+      );
+    }, 0), !(d in f))
+      return this.container;
+    const ee = z(this), ge = e.time;
+    for (const x of f[d]) {
+      const y = x.getState();
+      if (y === F.EMPTY)
+        continue;
+      const j = x.tileCoord;
+      if (y === F.LOADED && x.getAlpha(ee, ge) === 1) {
+        x.endTransition(ee);
+        continue;
+      }
+      if (y !== F.ERROR && (this.renderComplete = !1), this.findStaleTile_(j, f)) {
+        Me(f, x, d), e.animate = !0;
+        continue;
+      }
+      if (this.findAltTiles_(
+        l,
+        j,
+        d + 1,
+        f
+      ))
+        continue;
+      const I = l.getMinZoom();
+      for (let S = d - 1; S >= I && !this.findAltTiles_(
+        l,
+        j,
+        S,
+        f
+      ); --S)
+        ;
+    }
+    const k = g / u * c / h, p = this.getRenderContext(e);
+    Le(
+      this.tempTransform,
+      v / 2,
+      M / 2,
+      k,
+      k,
+      0,
+      -v / 2,
+      -M / 2
+    ), i.extent && this.clipUnrotated(p, e, m), n.getInterpolate() || (p.imageSmoothingEnabled = !1), this.preRender(p, e);
+    const G = Object.keys(f).map(Number);
+    G.sort(Re);
+    let _;
+    const Q = [], te = [];
+    for (let x = G.length - 1; x >= 0; --x) {
+      const y = G[x], j = n.getTilePixelSize(
+        y,
+        c,
+        a
+      ), D = l.getResolution(y) / g, I = j[0] * D * k, S = j[1] * D * k, b = l.getTileCoordForCoordAndZ(
+        Se(A),
+        y
+      ), ie = l.getTileCoordExtent(b), q = he(this.tempTransform, [
+        h * (ie[0] - A[0]) / g,
+        h * (A[3] - ie[3]) / g
+      ]), pe = h * n.getGutterForProjection(a);
+      for (const O of f[y]) {
+        if (O.getState() !== F.LOADED)
+          continue;
+        const ne = O.tileCoord, oe = b[1] - ne[1], Te = Math.round(q[0] - (oe - 1) * I), re = b[2] - ne[2], fe = Math.round(q[1] - (re - 1) * S), P = Math.round(q[0] - oe * I), L = Math.round(q[1] - re * S), U = Te - P, X = fe - L, se = G.length === 1;
+        let N = !1;
+        _ = [P, L, P + U, L, P + U, L + X, P, L + X];
+        for (let Y = 0, xe = Q.length; Y < xe; ++Y)
+          if (!se && y < te[Y]) {
+            const C = Q[Y];
+            we(
+              [P, L, P + U, L + X],
+              [C[0], C[3], C[4], C[7]]
+            ) && (N || (p.save(), N = !0), p.beginPath(), p.moveTo(_[0], _[1]), p.lineTo(_[2], _[3]), p.lineTo(_[4], _[5]), p.lineTo(_[6], _[7]), p.moveTo(C[6], C[7]), p.lineTo(C[4], C[5]), p.lineTo(C[2], C[3]), p.lineTo(C[0], C[1]), p.clip());
+          }
+        Q.push(_), te.push(y), this.drawTile(O, e, P, L, U, X, pe, se), N && p.restore(), this.renderedTiles.unshift(O), this.updateUsedTiles(e.usedTiles, n, O);
+      }
+    }
+    if (this.renderedResolution = g, this.extentChanged = !this.renderedExtent_ || !Ee(this.renderedExtent_, A), this.renderedExtent_ = A, this.renderedPixelRatio = c, this.postRender(this.context, e), i.extent && p.restore(), p.imageSmoothingEnabled = !0, this.renderComplete) {
+      const x = (y, j) => {
+        var S;
+        const B = z(n), D = j.wantedTiles[B], I = D ? Object.keys(D).length : 0;
+        this.updateCacheSize(I), this.tileCache_.expireCache(), (S = this.sourceTileCache_) == null || S.expireCache();
+      };
+      e.postRenderFunctions.push(x);
+    }
+    return this.container;
+  }
+  /**
+   * Increases the cache size if needed
+   * @param {number} tileCount Minimum number of tiles needed.
+   */
+  updateCacheSize(e) {
+    this.tileCache_.highWaterMark = Math.max(
+      this.tileCache_.highWaterMark,
+      e * 2
+    );
+  }
+  /**
+   * @param {import("../../Tile.js").default} tile Tile.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {number} x Left of the tile.
+   * @param {number} y Top of the tile.
+   * @param {number} w Width of the tile.
+   * @param {number} h Height of the tile.
+   * @param {number} gutter Tile gutter.
+   * @param {boolean} transition Apply an alpha transition.
+   * @protected
+   */
+  drawTile(e, t, i, o, a, u, s, c) {
+    let r;
+    if (e instanceof ce) {
+      if (r = le(e.getData()), !r)
+        throw new Error("Rendering array data is not yet supported");
+    } else
+      r = this.getTileImage(
+        /** @type {import("../../ImageTile.js").default} */
+        e
+      );
+    if (!r)
+      return;
+    const n = this.getRenderContext(t), l = z(this), d = t.layerStatesArray[t.layerIndex], g = d.opacity * (c ? e.getAlpha(l, t.time) : 1), T = g !== n.globalAlpha;
+    T && (n.save(), n.globalAlpha = g), n.drawImage(
+      r,
+      s,
+      s,
+      r.width - 2 * s,
+      r.height - 2 * s,
+      i,
+      o,
+      a,
+      u
+    ), T && n.restore(), g !== d.opacity ? t.animate = !0 : c && e.endTransition(l);
+  }
+  /**
+   * @return {HTMLCanvasElement|OffscreenCanvas} Image
+   */
+  getImage() {
+    const e = this.context;
+    return e ? e.canvas : null;
+  }
+  /**
+   * Get the image from a tile.
+   * @param {import("../../ImageTile.js").default} tile Tile.
+   * @return {HTMLCanvasElement|OffscreenCanvas|HTMLImageElement|HTMLVideoElement} Image.
+   * @protected
+   */
+  getTileImage(e) {
+    return e.getImage();
+  }
+  /**
+   * @param {!Object<string, !Object<string, boolean>>} usedTiles Used tiles.
+   * @param {import("../../source/Tile.js").default} tileSource Tile source.
+   * @param {import('../../Tile.js').default} tile Tile.
+   * @protected
+   */
+  updateUsedTiles(e, t, i) {
+    const o = z(t);
+    o in e || (e[o] = {}), e[o][i.getKey()] = !0;
+  }
+}
+const Ne = Ae;
+export {
+  Ne as default
+};