Fix build: add @types/node as explicit devDependency

Agent-Logs-Url: https://github.com/JonnyDawe/UK-Sewage-Map/sessions/c9b105bc-c502-42a2-b30b-b6d6151b6ce8

Author: Copilot

dist/assets/AGraphicContainer-a01TvULg.js

@@ -0,0 +1,216 @@
+import {
+  l4 as g,
+  ir as z,
+  ez as v,
+  eG as O,
+  eE as M,
+  l5 as V,
+  l6 as D,
+  kh as E,
+  l7 as I,
+  l8 as $,
+  jT as k,
+  l9 as w,
+  eF as b,
+  f8 as C,
+  la as F,
+} from './index.lazy-BFilFZ3v.js';
+import { i as L, r as N, n as T } from './TechniqueInstance-ORh6ZjaS.js';
+import { j as u } from './FeatureCommandQueue-BbqTKNbG.js';
+import { r as P } from './vec3f32-nZdmKIgz.js';
+import { e as U } from './Container-JJ8D-RVy.js';
+import { $ as j } from './dataViewUtils-Dzpw_nGB.js';
+import { E as x, o as H } from './VertexArrayObject-B9LXzLl2.js';
+let W = 0;
+function c(f, e) {
+  return new L(N(W++), f, e);
+}
+const h = {
+  visualVariableColor: null,
+  visualVariableOpacity: null,
+  visualVariableSizeMinMaxValue: null,
+  visualVariableSizeScaleStops: null,
+  visualVariableSizeStops: null,
+  visualVariableSizeUnitValue: null,
+  visualVariableRotation: null,
+  visualVariableSizeOutlineScaleStops: null,
+};
+class q {
+  constructor() {
+    (this.instances = {
+      fill: c(u.fill, { uniforms: h, optionalAttributes: { zoomRange: !0 } }),
+      marker: c(u.marker, { uniforms: h, optionalAttributes: { zoomRange: !0 } }),
+      line: c(u.line, { uniforms: h, optionalAttributes: { zoomRange: !0 } }),
+      text: c(u.text, {
+        uniforms: h,
+        optionalAttributes: { zoomRange: !0, referenceSymbol: !1, clipAngle: !1 },
+      }),
+      complexFill: c(u.complexFill, { uniforms: h, optionalAttributes: { zoomRange: !0 } }),
+      gradientFill: c(u.gradientFill, { uniforms: h, optionalAttributes: { zoomRange: !0 } }),
+      texturedLine: c(u.texturedLine, { uniforms: h, optionalAttributes: { zoomRange: !0 } }),
+      gradientStroke: c(u.gradientStroke, { uniforms: h, optionalAttributes: { zoomRange: !0 } }),
+      animatedMarker: c(u.animatedMarker, { uniforms: h, optionalAttributes: { zoomRange: !0 } }),
+    }),
+      (this._instancesById = Object.values(this.instances).reduce(
+        (e, t) => (e.set(t.instanceId, t), e),
+        new Map(),
+      ));
+  }
+  getInstance(e) {
+    return this._instancesById.get(e);
+  }
+}
+const G = Math.PI / 180,
+  Y = 4;
+class J extends U {
+  constructor(e) {
+    super(),
+      (this._program = null),
+      (this._vao = null),
+      (this._vertexBuffer = null),
+      (this._indexBuffer = null),
+      (this._dvsMat3 = g()),
+      (this._localOrigin = { x: 0, y: 0 }),
+      (this._getBounds = e);
+  }
+  destroy() {
+    this._vao &&
+      (this._vao.dispose(),
+      (this._vao = null),
+      (this._vertexBuffer = null),
+      (this._indexBuffer = null)),
+      (this._program = z(this._program));
+  }
+  doRender(e) {
+    const { context: t } = e,
+      r = this._getBounds();
+    if (r.length < 1) return;
+    this._createShaderProgram(t),
+      this._updateMatricesAndLocalOrigin(e),
+      this._updateBufferData(t, r),
+      t.setBlendingEnabled(!0),
+      t.setDepthTestEnabled(!1),
+      t.setStencilWriteMask(0),
+      t.setStencilTestEnabled(!1),
+      t.setBlendFunction(v.ONE, v.ONE_MINUS_SRC_ALPHA),
+      t.setColorMask(!0, !0, !0, !0);
+    const s = this._program;
+    t.bindVAO(this._vao),
+      t.useProgram(s),
+      s.setUniformMatrix3fv('u_dvsMat3', this._dvsMat3),
+      t.gl.lineWidth(1),
+      t.drawElements(O.LINES, 8 * r.length, M.UNSIGNED_INT, 0),
+      t.bindVAO();
+  }
+  _createTransforms() {
+    return { displayViewScreenMat3: g() };
+  }
+  _createShaderProgram(e) {
+    if (this._program) return;
+    const t = `precision highp float;
+        uniform mat3 u_dvsMat3;
+
+        attribute vec2 a_position;
+
+        void main() {
+          mediump vec3 pos = u_dvsMat3 * vec3(a_position, 1.0);
+          gl_Position = vec4(pos.xy, 0.0, 1.0);
+        }`,
+      r = `precision mediump float;
+      void main() {
+        gl_FragColor = vec4(0.75, 0.0, 0.0, 0.75);
+      }`;
+    this._program = e.programCache.acquire(t, r, S().attributes);
+  }
+  _updateMatricesAndLocalOrigin(e) {
+    const { state: t } = e,
+      { displayMat3: r, size: s, resolution: _, pixelRatio: a, rotation: o, viewpoint: i } = t,
+      l = G * o,
+      { x: n, y: R } = i.targetGeometry,
+      y = V(n, t.spatialReference);
+    (this._localOrigin.x = y), (this._localOrigin.y = R);
+    const p = a * s[0],
+      m = a * s[1],
+      A = _ * p,
+      B = _ * m,
+      d = D(this._dvsMat3);
+    E(d, d, r), I(d, d, $(p / 2, m / 2)), k(d, d, P(s[0] / A, -m / B, 1)), w(d, d, -l);
+  }
+  _updateBufferData(e, t) {
+    const { x: r, y: s } = this._localOrigin,
+      _ = 2 * Y * t.length,
+      a = new Float32Array(_),
+      o = new Uint32Array(8 * t.length);
+    let i = 0,
+      l = 0;
+    for (const n of t)
+      n &&
+        ((a[2 * i] = n[0] - r),
+        (a[2 * i + 1] = n[1] - s),
+        (a[2 * i + 2] = n[0] - r),
+        (a[2 * i + 3] = n[3] - s),
+        (a[2 * i + 4] = n[2] - r),
+        (a[2 * i + 5] = n[3] - s),
+        (a[2 * i + 6] = n[2] - r),
+        (a[2 * i + 7] = n[1] - s),
+        (o[l] = i + 0),
+        (o[l + 1] = i + 3),
+        (o[l + 2] = i + 3),
+        (o[l + 3] = i + 2),
+        (o[l + 4] = i + 2),
+        (o[l + 5] = i + 1),
+        (o[l + 6] = i + 1),
+        (o[l + 7] = i + 0),
+        (i += 4),
+        (l += 8));
+    if (
+      (this._vertexBuffer
+        ? this._vertexBuffer.setData(a.buffer)
+        : (this._vertexBuffer = x.createVertex(e, b.DYNAMIC_DRAW, a.buffer)),
+      this._indexBuffer
+        ? this._indexBuffer.setData(o)
+        : (this._indexBuffer = x.createIndex(e, b.DYNAMIC_DRAW, o)),
+      !this._vao)
+    ) {
+      const n = S();
+      this._vao = new H(
+        e,
+        n.attributes,
+        n.bufferLayouts,
+        new Map([['geometry', this._vertexBuffer]]),
+        this._indexBuffer,
+      );
+    }
+  }
+}
+const S = () =>
+  j('bounds', { geometry: [{ location: 0, name: 'a_position', count: 2, type: M.FLOAT }] });
+class re extends T {
+  constructor(e) {
+    super(e), (this._instanceStore = new q()), (this.checkHighlight = () => !0);
+  }
+  destroy() {
+    super.destroy(), (this._boundsRenderer = C(this._boundsRenderer));
+  }
+  get instanceStore() {
+    return this._instanceStore;
+  }
+  enableRenderingBounds(e) {
+    (this._boundsRenderer = new J(e)), this.requestRender();
+  }
+  get hasHighlight() {
+    return this.checkHighlight();
+  }
+  onTileData(e, t) {
+    e.onMessage(t), this.contains(e) || this.addChild(e), this.requestRender();
+  }
+  _renderChildren(e, t) {
+    e.selection = t;
+    for (const r of this.children) {
+      if (!r.visible) continue;
+      const s = r.getDisplayList(this._instanceStore, F.STRICT_ORDER);
+      s == null || s.render(e);
+    }
+  }
+}
+export { re as i };

dist/assets/Analysis-D3fcqMo2.js

@@ -0,0 +1,44 @@
+import {
+  aj as n,
+  bF as r,
+  bG as l,
+  bH as o,
+  bI as p,
+  A as s,
+  B as i,
+  R as c,
+} from './index.lazy-BFilFZ3v.js';
+let d = 0,
+  e = class extends n.JSONSupportMixin(r.ClonableMixin(l.IdentifiableMixin(o))) {
+    constructor(a) {
+      super(a), (this.id = `${Date.now().toString(16)}-analysis-${d++}`), (this.title = null);
+    }
+    get parent() {
+      return this._get('parent');
+    }
+    set parent(a) {
+      const t = this.parent;
+      if (t != null)
+        switch (t.type) {
+          case 'line-of-sight':
+          case 'dimension':
+          case 'viewshed':
+            t.releaseAnalysis(this);
+            break;
+          case '2d':
+          case '3d':
+            t.analyses.includes(this) && t.analyses.remove(this);
+        }
+      this._set('parent', a);
+    }
+    get isEditable() {
+      return this.requiredPropertiesForEditing.every(p);
+    }
+  };
+s([i({ type: String, constructOnly: !0, clonable: !1 })], e.prototype, 'id', void 0),
+  s([i({ type: String })], e.prototype, 'title', void 0),
+  s([i({ clonable: !1, value: null })], e.prototype, 'parent', null),
+  s([i({ readOnly: !0 })], e.prototype, 'isEditable', null),
+  (e = s([c('esri.analysis.Analysis')], e));
+const y = e;
+export { y as c };

dist/assets/ArcGISCachedService-7jDyAgad.js

@@ -0,0 +1,70 @@
+import { A as t, B as a, F as m, W as x, bJ as h, R as S } from './index.lazy-BFilFZ3v.js';
+import { e as I } from './TileInfoTilemapCache-9YMZN2MF.js';
+import { T as O } from './TilemapCache-CSj905Yr.js';
+const C = (y) => {
+  let l = class extends y {
+    constructor() {
+      super(...arguments),
+        (this.copyright = null),
+        (this.minScale = 0),
+        (this.maxScale = 0),
+        (this.spatialReference = null),
+        (this.tileInfo = null),
+        (this.tilemapCache = null);
+    }
+    destroy() {
+      var i, e;
+      (e = (i = this.tilemapCache) == null ? void 0 : i.destroy) == null || e.call(i);
+    }
+    readMinScale(i, e) {
+      return e.minLOD != null && e.maxLOD != null ? i : 0;
+    }
+    readMaxScale(i, e) {
+      return e.minLOD != null && e.maxLOD != null ? i : 0;
+    }
+    get supportsBlankTile() {
+      return this.version >= 10.2;
+    }
+    readTilemapCache(i, e, f) {
+      var u;
+      const v = (u = e.capabilities) == null ? void 0 : u.includes('Tilemap');
+      let { minLOD: n, maxLOD: o, minScale: p, maxScale: c } = e;
+      if (n == null && o == null && (p !== 0 || c !== 0)) {
+        const r = (s) => Math.round(1e4 * s) / 1e4;
+        (p = r(p || e.tileInfo.lods[0].scale)),
+          (c = r(c || e.tileInfo.lods[e.tileInfo.lods.length - 1].scale));
+        for (const s of e.tileInfo.lods) {
+          const d = r(s.scale);
+          (n = d >= p ? s.level : n), (o = d >= c ? s.level : o);
+        }
+      }
+      if (v) return new O({ layer: this, minLOD: n, maxLOD: o });
+      if (e.tileInfo) {
+        const r = new h();
+        return r.read(e.tileInfo, f), new I(r, n, o);
+      }
+      return null;
+    }
+  };
+  return (
+    t([a({ json: { read: { source: 'copyrightText' } } })], l.prototype, 'copyright', void 0),
+    t([a()], l.prototype, 'minScale', void 0),
+    t([m('service', 'minScale')], l.prototype, 'readMinScale', null),
+    t([a()], l.prototype, 'maxScale', void 0),
+    t([m('service', 'maxScale')], l.prototype, 'readMaxScale', null),
+    t([a({ type: x })], l.prototype, 'spatialReference', void 0),
+    t([a({ readOnly: !0 })], l.prototype, 'supportsBlankTile', null),
+    t([a({ type: h })], l.prototype, 'tileInfo', void 0),
+    t([a()], l.prototype, 'tilemapCache', void 0),
+    t(
+      [m('service', 'tilemapCache', ['capabilities', 'tileInfo'])],
+      l.prototype,
+      'readTilemapCache',
+      null,
+    ),
+    t([a()], l.prototype, 'version', void 0),
+    (l = t([S('esri.layers.mixins.ArcGISCachedService')], l)),
+    l
+  );
+};
+export { C as p };