@arcgis/api-extractor 5.0.0-next.135 → 5.0.0-next.137

package/dist/ApiExtractor-BwOcUvPV.js

@@ -0,0 +1,2644 @@
+import { l as j, a as re, e as Re, p as de } from "./typeScript-CzUTFiYO.js";
+import { a as be, o as xe, t as Ge, b as Le, c as Oe, e as Ne, d as Z, p as Be, f as We, i as fe, g as ze, h as Ue, j as je, k as He, n as Je, r as Ve } from "./worker-CULPfolw.js";
+import { getViewUrl as Xe, postProcessDeprecated as Q, postProcessDescription as D, postProcessDocsTags as J, resolveJsDocLink as Ye } from "./extractor/processing/links.js";
+import k from "typescript";
+import { path as O, toPosixPathSeparators as qe } from "@arcgis/components-build-utils";
+import { mkdir as se, writeFile as Pe } from "fs/promises";
+import x from "chalk";
+import { styleText as Ze } from "util";
+import { kebabToPascal as _e } from "@arcgis/toolkit/string";
+import { getModuleContext as h, getObjectLikeContext as K, getVariableContext as Ke, getFunctionLikeContext as Qe, getPropertyContext as ne, privateContextSymbol as et } from "./extractor/privateContext.js";
+import { apiTypeToImportType as ae, globalPackageIdentifier as Ie, getApiMemberName as tt, getMaybeStaticApiMemberName as le, mergeApiNodes as Se, naturalSortModules as it, compareNamedNodes as nt, compareClassMembers as ot } from "./utils/apiHelpers.js";
+import { printTypeParameters as te, printTypeAlias as rt } from "./utils/partPrinter.js";
+import { identity as ke, debounce as st } from "@arcgis/toolkit/function";
+import { opendirSync as at, watch as lt, readFileSync as ct, statSync as dt } from "node:fs";
+const me = "developers.arcgis.com", pe = "next.gha.afd.arcgis.com";
+let N, R, z, B, L = "", W = "", Y = "", ee = "";
+function ft(e, t) {
+  z = void 0, B = void 0, W = e.path, Y = "", ee = "";
+  const i = `import("./${W}.js")`;
+  let n = "";
+  const s = e.exports?.[0]?.declaration.name, a = h(e);
+  if (a.constructorPropertiesInterface !== void 0) {
+    const o = a.constructorPropertiesInterface;
+    ye(o), $.length !== 0 && (n += ue(o, W, o.name, t));
+  }
+  let r;
+  for (let o = 0; o < e.declarations.length; ++o) {
+    const l = e.declarations[o];
+    if (ye(l), $.length === 0)
+      continue;
+    const c = l.name === s, d = c ? "default" : l.name, m = l.kind === "function", f = l.kind === "variable";
+    if (m || f) {
+      if (m) {
+        if (l.name === r)
+          continue;
+        if (r = l.name, c) {
+          $.length !== 1 && t.emitError("Expected only a single @esriCompatibilityName tag on a default export function.", {
+            file: h(e).file,
+            node: void 0
+          }), q($[0], t), R === void 0 && t.emitError("Expected default export @esriCompatibilityName tag to include a #", {
+            file: h(e).file,
+            node: void 0
+          }), n += `  interface ${R} {
+    ${l.name}: typeof ${i}.${d};
+  }
+
+  const __${R}Mapped: ${R};
+  export const ${R}: typeof __${R}Mapped.${l.name};
+
+`;
+          continue;
+        }
+      } else if (f && c) {
+        $.length !== 1 && t.emitError("Expected only a single @esriCompatibilityName tag on a default export variable.", {
+          file: h(e).file,
+          node: void 0
+        }), q($[0], t), (R !== void 0 || N !== void 0) && t.emitError("Expected default export @esriCompatibilityName tag to not include a # or .", {
+          file: h(e).file,
+          node: void 0
+        }), n += `  export const ${L}: typeof ${i}.default;
+
+`;
+        continue;
+      }
+      for (let p = 0; p < $.length; ++p)
+        q($[p], t), f && z !== void 0 ? Y += `    export const ${L}: ${i}.${d};
+` : ee += `    ${L}: typeof ${i}.${d};
+`;
+    } else if (l.kind === "class" || l.kind === "mixin" || l.kind === "interface" && K(l).isMixinBaseClass === !0) {
+      const p = te(_(l.typeParameters, !1, W)), g = te(_(l.typeParameters, !1, void 0)), u = te(_(l.typeParameters, !0, void 0)), v = ` ${i}.${d}`;
+      for (let C = 0; C < $.length; ++C) {
+        if (q($[C], t), L.startsWith("$")) {
+          const b = L.slice(1);
+          n += mt(b, l, d, W);
+          continue;
+        }
+        const y = N === void 0 ? "  " : "    ";
+        n += `${y}export type ${L}${p} =${v}${g};
+${y}export const ${L}: typeof${v}${u};
+
+`;
+      }
+    } else l.kind === "interface" && (n += ue(l, W, d, t));
+  }
+  return Y.length > 0 && (z === void 0 && t.emitError("Invalid @esriCompatibilityName usage: Namespace name was not set correctly.", {
+    file: h(e).file,
+    node: void 0
+  }), n += `  namespace ${z} {
+${Y.slice(0, -1)}  }
+
+`), ee.length > 0 && (B === void 0 && t.emitError(
+    "Invalid @esriCompatibilityName usage: Classdec module interface name was not set correctly.",
+    {
+      file: h(e).file,
+      node: void 0
+    }
+  ), n += `  interface ${B} {
+${ee}  }
+
+  export const ${B}: ${B};
+
+`), n;
+}
+function ue(e, t, i, n) {
+  const s = te(_(e.typeParameters, !1, void 0)), a = _(e.typeParameters, !1, t), r = `import("./${t}.js").${i}${s}`;
+  let o = "";
+  for (let l = 0; l < $.length; ++l) {
+    q($[l], n);
+    const c = rt(L, a, void 0, r);
+    N === void 0 ? o += `  ${c}
+` : Y += `    ${c}
+
+`;
+  }
+  return o += `
+`, o;
+}
+function _(e, t, i) {
+  if (e === void 0)
+    return;
+  const n = [];
+  for (let s = 0; s < e.length; ++s) {
+    const a = e[s];
+    if (i !== void 0) {
+      const r = a.constraint === void 0 ? void 0 : ae(a.constraint, i), o = a.default === void 0 ? r ?? {
+        text: "any",
+        references: void 0,
+        values: void 0,
+        source: void 0
+      } : ae(a.default, i);
+      n.push({
+        ...a,
+        default: o,
+        constraint: r
+      });
+    } else if (t) {
+      if (a.default !== void 0)
+        break;
+      n.push({
+        name: "any",
+        constraint: void 0,
+        default: void 0,
+        const: void 0,
+        in: void 0,
+        out: void 0
+      });
+    } else
+      n.push({
+        name: a.name,
+        constraint: void 0,
+        default: void 0,
+        const: void 0,
+        in: void 0,
+        out: void 0
+      });
+  }
+  return n.length === 0 ? void 0 : n;
+}
+const ie = [];
+let $ = ie;
+function ye(e) {
+  e.kind === "variable" ? $ = Ke(e).esriCompatibilityNames ?? ie : e.kind === "function" ? $ = Qe(e).esriCompatibilityNames ?? ie : $ = K(e).esriCompatibilityNames ?? ie;
+}
+function q(e, t) {
+  const i = e.indexOf(".");
+  if (i !== -1) {
+    N = e.slice(0, i), R = void 0, L = e.slice(i + 1), z === void 0 ? z = N : z !== N && t.emitError(
+      `Invalid @esriCompatibilityName usage: Multiple different namespaces in a single file are not supported. Found ${z} and ${N}`,
+      {
+        file: void 0,
+        scope: W,
+        node: void 0
+      }
+    );
+    return;
+  }
+  const n = e.indexOf("#");
+  if (n !== -1) {
+    N = void 0, R = e.slice(0, n), L = e.slice(n + 1), B === void 0 ? B = R : B !== R && t.emitError(
+      `Invalid @esriCompatibilityName usage: Multiple different __esri interfaces in a single file are not supported. Found ${B} and ${R}`,
+      {
+        file: void 0,
+        scope: W,
+        node: void 0
+      }
+    );
+    return;
+  }
+  N = void 0, R = void 0, L = e;
+}
+function mt(e, t, i, n) {
+  const s = pt(e, t.events), r = `${// IdentityManager fake class got renamed to IdentityManagerBase real class
+  t.name.startsWith($[0]) ? $[0] : t.name}${_e(e)}Event`, o = ut(s, n) ?? ` = import("./${n}.js").${i}["@eventTypes"]["${e}"]`, l = o.startsWith("<") ? o.indexOf(">") + 1 : -1, c = l !== -1 ? o.slice(0, l) : "";
+  return `  export type ${r}${o};
+  export type ${r}Handler${c} = (event: ${r}${c}) => void;
+
+`;
+}
+function pt(e, t) {
+  if (t !== void 0)
+    for (let i = 0; i < t.length; ++i) {
+      const n = t[i];
+      if (n.name === e)
+        return n;
+    }
+}
+function ut(e, t) {
+  const i = e?.type;
+  if (t = e?.inheritedFrom?.module ?? t, i?.references?.length === 1) {
+    const a = i.references[0];
+    if (a.package === void 0 && a.viewUrl !== void 0 && i.text === a.name)
+      return ` = import("./${a.module ?? t}.js").${a.name}`;
+  }
+  if (i?.references?.length !== 2)
+    return;
+  const n = i.references[0], s = i.references[1];
+  if (!(n.package !== void 0 || s.package !== void 0 || s.module !== void 0 || s.viewUrl !== void 0) && i.text === `${n.name}<${s.name}>`)
+    return t = n.module ?? t, `<${s.name}> = import("./${t}.js").${n.name}<${s.name}>`;
+}
+const yt = `type HashMap<T> = Record<string, T | undefined>;
+type nullish = null | undefined;
+
+type IHandle = import("./core/Handles").ResourceHandle;
+
+type GroupKey<T> = import("./core/Accessor").GroupKey<T>;
+
+declare namespace __esri {
+  type Constructor<T> = new (...params: any[]) => T;
+
+  export type AnonymousAccessor = Accessor;
+
+  export type ReadonlyAccessor = Omit<Accessor, "set" | "_set" | "destroy" | "notifyChange" | "_get">;
+
+`, ht = `
+
+  export namespace CIM {
+    export enum ExpressionReturnType {
+      Default = "Default",
+      String = "String",
+      Numeric = "Numeric"
+    }
+
+    export enum AngleAlignment {
+      Display = "Display",
+      Map = "Map"
+    }
+
+    export enum BalloonCalloutStyle {
+      Rectangle = "Rectangle",
+      RoundedRectangle = "RoundedRectangle",
+      Oval = "Oval"
+    }
+
+    export enum BlendingMode {
+      None = "None",
+      Alpha = "Alpha",
+      Screen = "Screen",
+      Multiply = "Multiply",
+      Add = "Add"
+    }
+
+    export enum BlockProgression {
+      TTB = "TTB",
+      RTL = "RTL",
+      BTT = "BTT"
+    }
+
+    export enum CGAAttributeType {
+      Float = "Float",
+      String = "String",
+      Boolean = "Boolean"
+    }
+
+    export enum ClippingType {
+      Intersect = "Intersect",
+      Subtract = "Subtract"
+    }
+
+    export enum ExternalColorMixMode {
+      Tint = "Tint",
+      Ignore = "Ignore",
+      Multiply = "Multiply"
+    }
+
+    export enum ExtremityPlacement {
+      Both = "Both",
+      JustBegin = "JustBegin",
+      JustEnd = "JustEnd",
+      None = "None"
+    }
+
+    export enum FillMode {
+      Mosaic = "Mosaic",
+      Centered = "Centered"
+    }
+
+    export enum FontEffects {
+      Normal = "Normal",
+      Superscript = "Superscript",
+      Subscript = "Subscript"
+    }
+
+    export enum FontEncoding {
+      MSSymbol = "MSSymbol",
+      Unicode = "Unicode"
+    }
+
+    export enum FontType {
+      Unspecified = "Unspecified",
+      TrueType = "TrueType",
+      PSOpenType = "PSOpenType",
+      TTOpenType = "TTOpenType",
+      Type1 = "Type1"
+    }
+
+    export enum GeometricEffectArrowType {
+      OpenEnded = "OpenEnded",
+      Block = "Block",
+      Crossed = "Crossed"
+    }
+
+    export enum GeometricEffectDonutMethod {
+      Mitered = "Mitered",
+      Bevelled = "Bevelled",
+      Rounded = "Rounded",
+      Square = "Square",
+      TrueBuffer = "TrueBuffer"
+    }
+
+    export enum GeometricEffectEnclosingPolygonMethod {
+      ClosePath = "ClosePath",
+      ConvexHull = "ConvexHull",
+      RectangularBox = "RectangularBox"
+    }
+
+    export enum GeometricEffectExtensionOrigin {
+      BeginningOfLine = "BeginningOfLine",
+      EndOfLine = "EndOfLine"
+    }
+
+    export enum GeometricEffectLocalizerFeatherStyle {
+      Complete = "Complete",
+      Left = "Left",
+      Right = "Right"
+    }
+
+    export enum GeometricEffectOffsetMethod {
+      Mitered = "Mitered",
+      Bevelled = "Bevelled",
+      Rounded = "Rounded",
+      Square = "Square"
+    }
+
+    export enum GeometricEffectOffsetOption {
+      Fast = "Fast",
+      Accurate = "Accurate"
+    }
+
+    export enum GeometricEffectOffsetTangentMethod {
+      BeginningOfLine = "BeginningOfLine",
+      EndOfLine = "EndOfLine"
+    }
+
+    export enum GeometricEffectWaveform {
+      Sinus = "Sinus",
+      Square = "Square",
+      Triangle = "Triangle",
+      Random = "Random"
+    }
+
+    export enum GlyphHinting {
+      None = "None",
+      Default = "Default",
+      Force = "Force"
+    }
+
+    export enum GradientAlignment {
+      Buffered = "Buffered",
+      Left = "Left",
+      Right = "Right",
+      AlongLine = "AlongLine"
+    }
+
+    export enum GradientFillMethod {
+      Linear = "Linear",
+      Rectangular = "Rectangular",
+      Circular = "Circular",
+      Buffered = "Buffered"
+    }
+
+    export enum GradientStrokeType {
+      Discrete = "Discrete",
+      Continuous = "Continuous"
+    }
+
+    export enum HorizontalAlignment {
+      Left = "Left",
+      Right = "Right",
+      Center = "Center",
+      Justify = "Justify"
+    }
+
+    export enum LeaderLineStyle {
+      Base = "Base",
+      MidPoint = "MidPoint",
+      ThreePoint = "ThreePoint",
+      FourPoint = "FourPoint",
+      Underline = "Underline",
+      CircularCW = "CircularCW",
+      CircularCCW = "CircularCCW"
+    }
+
+    export enum LineCapStyle {
+      Butt = "Butt",
+      Round = "Round",
+      Square = "Square"
+    }
+
+    export enum LineDashEnding {
+      NoConstraint = "NoConstraint",
+      HalfPattern = "HalfPattern",
+      HalfGap = "HalfGap",
+      FullPattern = "FullPattern",
+      FullGap = "FullGap",
+      Custom = "Custom"
+    }
+
+    export enum LineDecorationStyle {
+      None = "None",
+      Custom = "Custom",
+      Circle = "Circle",
+      OpenArrow = "OpenArrow",
+      ClosedArrow = "ClosedArrow",
+      Diamond = "Diamond"
+    }
+
+    export enum LineGapType {
+      ExtraLeading = "ExtraLeading",
+      Multiple = "Multiple",
+      Exact = "Exact"
+    }
+
+    export enum LineJoinStyle {
+      Bevel = "Bevel",
+      Round = "Round",
+      Miter = "Miter"
+    }
+
+    export enum MarkerPlacementType {
+      InsidePolygon = "InsidePolygon",
+      PolygonCenter = "PolygonCenter",
+      RandomlyInsidePolygon = "RandomlyInsidePolygon"
+    }
+
+    export enum MaterialMode {
+      Tint = "Tint",
+      Replace = "Replace",
+      Multiply = "Multiply"
+    }
+
+    export enum PlacementClip {
+      ClipAtBoundary = "ClipAtBoundary",
+      RemoveIfCenterOutsideBoundary = "RemoveIfCenterOutsideBoundary",
+      DoNotTouchBoundary = "DoNotTouchBoundary",
+      DoNotClip = "DoNotClip"
+    }
+
+    export enum PlacementEndings {
+      NoConstraint = "NoConstraint",
+      WithMarkers = "WithMarkers",
+      WithFullGap = "WithFullGap",
+      WithHalfGap = "WithHalfGap",
+      Custom = "Custom"
+    }
+
+    export enum PlacementGridType {
+      Fixed = "Fixed",
+      Random = "Random",
+      RandomFixedQuantity = "RandomFixedQuantity"
+    }
+
+    export enum PlacementOnLineRelativeTo {
+      LineMiddle = "LineMiddle",
+      LineBeginning = "LineBeginning",
+      LineEnd = "LineEnd",
+      SegmentMidpoint = "SegmentMidpoint"
+    }
+
+    export enum PlacementPolygonCenterMethod {
+      OnPolygon = "OnPolygon",
+      CenterOfMass = "CenterOfMass",
+      BoundingBoxCenter = "BoundingBoxCenter"
+    }
+
+    export enum PlacementRandomlyAlongLineRandomization {
+      Low = "Low",
+      Medium = "Medium",
+      High = "High"
+    }
+
+    export enum PlacementStepPosition {
+      MarkerCenter = "MarkerCenter",
+      MarkerBounds = "MarkerBounds"
+    }
+
+    export enum PointSymbolCalloutScale {
+      None = "None",
+      PropUniform = "PropUniform",
+      PropNonuniform = "PropNonuniform",
+      DifUniform = "DifUniform",
+      DifNonuniform = "DifNonuniform"
+    }
+
+    export enum Simple3DLineStyle {
+      Tube = "Tube",
+      Strip = "Strip",
+      Wall = "Wall"
+    }
+
+    export enum SizeVariationMethod {
+      Random = "Random",
+      Increasing = "Increasing",
+      Decreasing = "Decreasing",
+      IncreasingThenDecreasing = "IncreasingThenDecreasing"
+    }
+
+    export enum SymbolUnits {
+      Relative = "Relative",
+      Absolute = "Absolute"
+    }
+
+    export enum TextCase {
+      Normal = "Normal",
+      LowerCase = "LowerCase",
+      Allcaps = "Allcaps"
+    }
+
+    export enum TextReadingDirection {
+      LTR = "LTR",
+      RTL = "RTL"
+    }
+
+    export enum TextureFilter {
+      Draft = "Draft",
+      Picture = "Picture",
+      Text = "Text"
+    }
+
+    export enum VerticalAlignment {
+      Top = "Top",
+      Center = "Center",
+      Baseline = "Baseline",
+      Bottom = "Bottom"
+    }
+
+    export enum VerticalGlyphOrientation {
+      Right = "Right",
+      Upright = "Upright"
+    }
+
+    export enum WaterbodySize {
+      Small = "Small",
+      Medium = "Medium",
+      Large = "Large"
+    }
+
+    export enum WaveStrength {
+      Calm = "Calm",
+      Rippled = "Rippled",
+      Slight = "Slight",
+      Moderate = "Moderate"
+    }
+
+    export enum BillboardMode {
+      None = "None",
+      SignPost = "SignPost",
+      FaceNearPlane = "FaceNearPlane"
+    }
+
+    export enum DominantSizeAxis {
+      Z = "Z",
+      X = "X",
+      Y = "Y"
+    }
+
+    export enum GradientStrokeMethod {
+      AcrossLine = "AcrossLine",
+      AlongLine = "AlongLine"
+    }
+
+    export enum RotationOrder {
+      XYZ = "XYZ",
+      ZXY = "ZXY",
+      YXZ = "YXZ"
+    }
+
+    export interface CIMExpressionInfo {
+      type: "CIMExpressionInfo";
+      title?: string;
+      expression?: string;
+      name?: string;
+      returnType?: keyof typeof ExpressionReturnType;
+    }
+
+    export interface CIMPrimitiveOverride {
+      type: "CIMPrimitiveOverride";
+      primitiveName?: string;
+      propertyName?: string;
+      expression?: string;
+      valueExpressionInfo?: CIMExpressionInfo;
+    }
+
+    export interface CIMScaleDependentSizeVariation {
+      type: "CIMScaleDependentSizeVariation";
+      scale?: number;
+      size?: number;
+    }
+
+    export interface CIMSymbolReference {
+      type: "CIMSymbolReference";
+      primitiveOverrides?: CIMPrimitiveOverride[];
+      stylePath?: string;
+      symbol?: CIMSymbolType;
+      symbolName?: string;
+      minScale?: number;
+      maxScale?: number;
+      scaleDependentSizeVariation?: CIMScaleDependentSizeVariation[];
+      minDistance?: number;
+      maxDistance?: number;
+    }
+
+    export interface CIM3DSymbolProperties {
+      type: "CIM3DSymbolProperties";
+      dominantSizeAxis3D?: keyof typeof DominantSizeAxis;
+      rotationOrder3D?: keyof typeof RotationOrder;
+      scaleZ?: number;
+      scaleY?: number;
+    }
+
+    export interface CIMCalloutBase {
+      type: string;
+      leaderTolerance?: number;
+      leaderOffset?: number;
+    }
+
+    export interface CIMLineCallout extends CIMCalloutBase {
+      leaderLineSymbol?: CIMLineSymbol;
+      gap?: number;
+      lineStyle?: keyof typeof LeaderLineStyle;
+    }
+
+    export interface CIMSymbolLayerBase {
+      type: string;
+      effects?: CIMGeometricEffectType[];
+      enable?: boolean;
+      name?: string;
+      colorLocked?: boolean;
+      primitiveName?: string;
+      overprint?: boolean;
+    }
+
+    export interface CIMMarker extends CIMSymbolLayerBase {
+      anchorPoint?: ExternalReferencePoint;
+      anchorPointUnits?: keyof typeof SymbolUnits;
+      angleX?: number;
+      angleY?: number;
+      dominantSizeAxis3D?: keyof typeof DominantSizeAxis;
+      offsetX?: number;
+      offsetY?: number;
+      offsetZ?: number;
+      rotateClockwise?: boolean;
+      rotation?: number;
+      size?: number;
+      billboardMode3D?: keyof typeof BillboardMode;
+      markerPlacement?: CIMMarkerPlacementType;
+    }
+
+    export interface CIMCGAAttribute {
+      type: "CIMCGAAttribute";
+      name?: string;
+      CGAAttributeType?: keyof typeof CGAAttributeType;
+      value?: any;
+    }
+
+    export interface CIMCharacterMarker extends CIMMarker {
+      type: "CIMCharacterMarker";
+      characterIndex?: number;
+      depth3D?: number;
+      fontFamilyName?: string;
+      fontStyleName?: string;
+      fontType?: keyof typeof FontType;
+      scaleX?: number;
+      symbol?: CIMPolygonSymbol;
+      verticalOrientation3D?: boolean;
+      scaleSymbolsProportionally?: boolean;
+      respectFrame?: boolean;
+    }
+
+    export interface CIMClippingPath {
+      type: "CIMClippingPath";
+      clippingType?: keyof typeof ClippingType;
+      path?: ExternalReferencePolygon;
+    }
+
+    export interface CIMColorSubstitution {
+      type: "CIMColorSubstitution";
+      oldColor?: number[];
+      newColor?: number[];
+    }
+
+    export interface CIMGeometricEffectBase {
+      type: string;
+      primitiveName?: string;
+    }
+
+    export interface CIMGeometricEffectAddControlPoints extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectAddControlPoints";
+      angleTolerance?: number;
+    }
+
+    export interface CIMGeometricEffectArrow extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectArrow";
+      geometricEffectArrowType?: keyof typeof GeometricEffectArrowType;
+      width?: number;
+    }
+
+    export interface CIMGeometricEffectBuffer extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectBuffer";
+      size?: number;
+    }
+
+    export interface CIMGeometricEffectCut extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectCut";
+      beginCut?: number;
+      endCut?: number;
+      middleCut?: number;
+      invert?: boolean;
+    }
+
+    export interface CIMGeometricEffectDashes extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectDashes";
+      customEndingOffset?: number;
+      dashTemplate?: number[];
+      lineDashEnding?: keyof typeof LineDashEnding;
+      offsetAlongLine?: number;
+      controlPointEnding?: keyof typeof LineDashEnding;
+    }
+
+    export interface CIMGeometricEffectDonut extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectDonut";
+      method?: keyof typeof GeometricEffectDonutMethod;
+      option?: keyof typeof GeometricEffectOffsetOption;
+      width?: number;
+    }
+
+    export interface CIMGeometricEffectEnclosingPolygon extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectEnclosingPolygon";
+      method?: keyof typeof GeometricEffectEnclosingPolygonMethod;
+    }
+
+    export interface CIMGeometricEffectExtension extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectExtension";
+      deflection?: number;
+      origin?: keyof typeof GeometricEffectExtensionOrigin;
+      length?: number;
+    }
+
+    export interface CIMGeometricEffectJog extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectJog";
+      angle?: number;
+      length?: number;
+      position?: number;
+    }
+
+    export interface CIMGeometricEffectLocalizerFeather extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectLocalizerFeather";
+      style?: keyof typeof GeometricEffectLocalizerFeatherStyle;
+      length?: number;
+      width?: number;
+      angle?: number;
+    }
+
+    export interface CIMGeometricEffectMove extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectMove";
+      offsetX?: number;
+      offsetY?: number;
+    }
+
+    export interface CIMGeometricEffectOffset extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectOffset";
+      method?: keyof typeof GeometricEffectOffsetMethod;
+      offset?: number;
+      option?: keyof typeof GeometricEffectOffsetOption;
+    }
+
+    export interface CIMGeometricEffectOffsetHatch extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectOffsetHatch";
+      length?: number;
+      spacing?: number;
+    }
+
+    export interface CIMGeometricEffectOffsetTangent extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectOffsetTangent";
+      method?: keyof typeof GeometricEffectOffsetTangentMethod;
+      offset?: number;
+    }
+
+    export interface CIMGeometricEffectRadial extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectRadial";
+      angle?: number;
+      length?: number;
+    }
+
+    export interface CIMGeometricEffectRegularPolygon extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectRegularPolygon";
+      angle?: number;
+      edges?: number;
+      radius?: number;
+    }
+
+    export interface CIMGeometricEffectReverse extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectReverse";
+      reverse?: boolean;
+    }
+
+    export interface CIMGeometricEffectRotate extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectRotate";
+      angle?: number;
+    }
+
+    export interface CIMGeometricEffectScale extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectScale";
+      XScaleFactor?: number;
+      YScaleFactor?: number;
+    }
+
+    export interface CIMGeometricEffectSuppress extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectSuppress";
+      suppress?: boolean;
+      invert?: boolean;
+    }
+
+    export interface CIMGeometricEffectTaperedPolygon extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectTaperedPolygon";
+      fromWidth?: number;
+      length?: number;
+      toWidth?: number;
+    }
+
+    export interface CIMGeometricEffectWave extends CIMGeometricEffectBase {
+      type: "CIMGeometricEffectWave";
+      amplitude?: number;
+      period?: number;
+      seed?: number;
+      waveform?: keyof typeof GeometricEffectWaveform;
+    }
+
+    export interface CIMFill extends CIMSymbolLayerBase {}
+
+    export interface CIMGradientFill extends CIMFill {
+      type: "CIMGradientFill";
+      angle?: number;
+      colorRamp?: any;
+      gradientMethod?: keyof typeof GradientFillMethod;
+      gradientSize?: number;
+      gradientSizeUnits?: keyof typeof SymbolUnits;
+      gradientType?: keyof typeof GradientStrokeType;
+      interval?: number;
+    }
+
+    export interface CIMStroke extends CIMSymbolLayerBase {
+      capStyle?: keyof typeof LineCapStyle;
+      joinStyle?: keyof typeof LineJoinStyle;
+      lineStyle3D?: keyof typeof Simple3DLineStyle;
+      miterLimit?: number;
+      width?: number;
+      closeCaps3D?: boolean;
+    }
+
+    export interface CIMGradientStroke extends CIMStroke {
+      type: "CIMGradientStroke";
+      colorRamp?: any;
+      gradientMethod?: keyof typeof GradientStrokeMethod;
+      gradientSize?: number;
+      gradientSizeUnits?: keyof typeof SymbolUnits;
+      gradientType?: keyof typeof GradientStrokeType;
+      interval?: number;
+    }
+
+    export interface CIMHatchFill extends CIMFill {
+      type: "CIMHatchFill";
+      lineSymbol?: CIMLineSymbol;
+      offsetX?: number;
+      rotation?: number;
+      separation?: number;
+      offsetY?: number;
+    }
+
+    export interface CIMSymbolBase {
+      type: string;
+    }
+
+    export interface CIMMultiLayerSymbol extends CIMSymbolBase {
+      effects?: CIMGeometricEffectType[];
+      symbolLayers?: CIMSymbolLayerType[];
+      thumbnailURI?: string;
+      useRealWorldSymbolSizes?: boolean;
+    }
+
+    export interface CIMLineSymbol extends CIMMultiLayerSymbol {
+      type: "CIMLineSymbol";
+    }
+
+    export interface CIMMarkerGraphic {
+      type: "CIMMarkerGraphic";
+      geometry?: ExternalReferenceGeometry;
+      symbol?: CIMSymbolType;
+      textString?: string;
+      primitiveName?: string;
+    }
+
+    export interface CIMMarkerPlacementBase {
+      type: string;
+      primitiveName?: string;
+    }
+
+    export interface CIMMarkerStrokePlacement extends CIMMarkerPlacementBase {
+      angleToLine?: boolean;
+      offset?: number;
+    }
+
+    export interface CIMMarkerPlacementAlongLine extends CIMMarkerStrokePlacement {
+      controlPointPlacement?: keyof typeof PlacementEndings;
+      customEndingOffset?: number;
+      endings?: keyof typeof PlacementEndings;
+      offsetAlongLine?: number;
+      placementTemplate?: number[];
+    }
+
+    export interface CIMMarkerPlacementAlongLineRandomSize extends CIMMarkerPlacementAlongLine {
+      type: "CIMMarkerPlacementAlongLineRandomSize";
+      randomization?: keyof typeof PlacementRandomlyAlongLineRandomization;
+      seed?: number;
+    }
+
+    export interface CIMMarkerPlacementAlongLineSameSize extends CIMMarkerPlacementAlongLine {
+      type: "CIMMarkerPlacementAlongLineSameSize";
+    }
+
+    export interface CIMMarkerPlacementAlongLineVariableSize extends CIMMarkerPlacementAlongLine {
+      type: "CIMMarkerPlacementAlongLineVariableSize";
+      maxRandomOffset?: number;
+      maxZoom?: number;
+      minZoom?: number;
+      numberOfSizes?: number;
+      seed?: number;
+      variationMethod?: keyof typeof SizeVariationMethod;
+    }
+
+    export interface CIMMarkerPlacementAtExtremities extends CIMMarkerStrokePlacement {
+      type: "CIMMarkerPlacementAtExtremities";
+      extremityPlacement?: keyof typeof ExtremityPlacement;
+      offsetAlongLine?: number;
+    }
+
+    export interface CIMMarkerPlacementAtMeasuredUnits extends CIMMarkerStrokePlacement {
+      type: "CIMMarkerPlacementAtMeasuredUnits";
+      interval?: number;
+      skipMarkerRate?: number;
+      placeAtExtremities?: boolean;
+    }
+
+    export interface CIMMarkerPlacementAtRatioPositions extends CIMMarkerStrokePlacement {
+      type: "CIMMarkerPlacementAtRatioPositions";
+      beginPosition?: number;
+      endPosition?: number;
+      flipFirst?: boolean;
+      positionArray?: number[];
+    }
+
+    export interface CIMMarkerFillPlacement extends CIMMarkerPlacementBase {}
+
+    export interface CIMMarkerPlacementInsidePolygon extends CIMMarkerFillPlacement {
+      type: "CIMMarkerPlacementInsidePolygon";
+      gridAngle?: number;
+      gridType?: keyof typeof PlacementGridType;
+      offsetX?: number;
+      randomness?: number;
+      seed?: number;
+      shiftOddRows?: boolean;
+      stepX?: number;
+      stepY?: number;
+      offsetY?: number;
+      clipping?: keyof typeof PlacementClip;
+    }
+
+    export interface CIMMarkerPlacementOnLine extends CIMMarkerStrokePlacement {
+      type: "CIMMarkerPlacementOnLine";
+      relativeTo?: keyof typeof PlacementOnLineRelativeTo;
+      startPointOffset?: number;
+    }
+
+    export interface CIMMarkerPlacementOnVertices extends CIMMarkerStrokePlacement {
+      type: "CIMMarkerPlacementOnVertices";
+      placeOnControlPoints?: boolean;
+      placeOnEndPoints?: boolean;
+      placeOnRegularVertices?: boolean;
+    }
+
+    export interface CIMMarkerPlacementPolygonCenter extends CIMMarkerFillPlacement {
+      type: "CIMMarkerPlacementPolygonCenter";
+      method?: keyof typeof PlacementPolygonCenterMethod;
+      offsetX?: number;
+      offsetY?: number;
+      clipAtBoundary?: boolean;
+    }
+
+    export interface CIMMaterialProperties {
+      type: "CIMMaterialProperties";
+      specularColor?: number[];
+      shininess?: number;
+      externalColorMixMode?: keyof typeof ExternalColorMixMode;
+    }
+
+    export interface CIMMaterialSymbolLayer extends CIMSymbolLayerBase {
+      type: "CIMMaterialSymbolLayer";
+      color?: number[];
+      materialMode?: keyof typeof MaterialMode;
+    }
+
+    export interface CIMObjectMarker3D extends CIMMarker {
+      type: "CIMObjectMarker3D";
+      modelURI?: string;
+      width?: number;
+      depth?: number;
+      tintColor?: number[];
+      isRestricted?: boolean;
+      thumbnail?: string;
+      useAnchorPoint?: boolean;
+      LODs?: CIMObjectMarker3DLOD[];
+    }
+
+    export interface CIMObjectMarker3DLOD {
+      type: "CIMObjectMarker3DLOD";
+      faceCount?: number;
+      modelURI?: string;
+    }
+
+    export interface CIMPictureFill extends CIMFill {
+      type: "CIMPictureFill";
+      url?: string;
+      offsetX?: number;
+      offsetY?: number;
+      rotation?: number;
+      scaleX?: number;
+      height?: number;
+      textureFilter?: keyof typeof TextureFilter;
+      colorSubstitutions?: CIMColorSubstitution[];
+      tintColor?: number[];
+    }
+
+    export interface CIMPictureMarker extends CIMMarker {
+      type: "CIMPictureMarker";
+      colorSubstitutions?: CIMColorSubstitution[];
+      depth3D?: number;
+      invertBackfaceTexture?: boolean;
+      scaleX?: number;
+      textureFilter?: keyof typeof TextureFilter;
+      tintColor?: number[];
+      url?: string;
+      verticalOrientation3D?: boolean;
+    }
+
+    export interface CIMPictureStroke extends CIMStroke {
+      type: "CIMPictureStroke";
+      colorSubstitutions?: CIMColorSubstitution[];
+      textureFilter?: keyof typeof TextureFilter;
+      url?: string;
+      tintColor?: number[];
+    }
+
+    export interface CIMPointSymbol extends CIMMultiLayerSymbol {
+      type: "CIMPointSymbol";
+      callout?: CIMCalloutType;
+      haloSize?: number;
+      haloSymbol?: CIMPolygonSymbol;
+      primitiveName?: string;
+      scaleX?: number;
+      symbol3DProperties?: CIM3DSymbolProperties;
+      angle?: number;
+      angleAlignment?: keyof typeof AngleAlignment;
+    }
+
+    export interface CIMPolygonSymbol extends CIMMultiLayerSymbol {
+      type: "CIMPolygonSymbol";
+    }
+
+    export interface CIMShapeVertices {
+      type: "CIMShapeVertices";
+      indices?: number;
+      shapes?: string;
+    }
+
+    export interface CIMSolidFill extends CIMFill {
+      type: "CIMSolidFill";
+      color?: number[];
+    }
+
+    export interface CIMSolidStroke extends CIMStroke {
+      type: "CIMSolidStroke";
+      color?: number[];
+    }
+
+    export interface CIMTextMargin {
+      type: "CIMTextMargin";
+      left?: number;
+      right?: number;
+      top?: number;
+      bottom?: number;
+    }
+
+    export interface CIMTextSymbol extends CIMSymbolBase {
+      type: "CIMTextSymbol";
+      angle?: number;
+      angleX?: number;
+      angleY?: number;
+      blockProgression?: keyof typeof BlockProgression;
+      callout?: CIMCalloutType;
+      compatibilityMode?: boolean;
+      countryISO?: string;
+      depth3D?: number;
+      drawGlyphsAsGeometry?: boolean;
+      drawSoftHyphen?: boolean;
+      extrapolateBaselines?: boolean;
+      flipAngle?: number;
+      fontEffects?: keyof typeof FontEffects;
+      fontEncoding?: keyof typeof FontEncoding;
+      fontFamilyName?: string;
+      fontStyleName?: string;
+      fontType?: keyof typeof FontType;
+      glyphRotation?: number;
+      haloSize?: number;
+      haloSymbol?: CIMPolygonSymbol;
+      height?: number;
+      hinting?: keyof typeof GlyphHinting;
+      horizontalAlignment?: keyof typeof HorizontalAlignment;
+      indentAfter?: number;
+      indentBefore?: number;
+      indentFirstLine?: number;
+      kerning?: boolean;
+      languageISO?: string;
+      letterSpacing?: number;
+      letterWidth?: number;
+      ligatures?: boolean;
+      lineGap?: number;
+      lineGapType?: keyof typeof LineGapType;
+      offsetX?: number;
+      offsetY?: number;
+      offsetZ?: number;
+      shadowColor?: number[];
+      shadowOffsetX?: number;
+      shadowOffsetY?: number;
+      smallCaps?: boolean;
+      strikethrough?: boolean;
+      symbol?: CIMPolygonSymbol;
+      symbol3DProperties?: CIM3DSymbolProperties;
+      textCase?: keyof typeof TextCase;
+      textDirection?: keyof typeof TextReadingDirection;
+      underline?: boolean;
+      verticalAlignment?: keyof typeof VerticalAlignment;
+      verticalGlyphOrientation?: keyof typeof VerticalGlyphOrientation;
+      wordSpacing?: number;
+      billboardMode3D?: keyof typeof BillboardMode;
+      overprint?: boolean;
+    }
+
+    export interface CIMVectorMarker extends CIMMarker {
+      type: "CIMVectorMarker";
+      depth3D?: number;
+      frame?: ExternalReferenceEnvelope;
+      markerGraphics?: CIMMarkerGraphic[];
+      verticalOrientation3D?: boolean;
+      scaleSymbolsProportionally?: boolean;
+      respectFrame?: boolean;
+      clippingPath?: CIMClippingPath;
+    }
+
+    export type CIMMarkerPlacementType =
+      | CIMMarkerPlacementAlongLineRandomSize
+      | CIMMarkerPlacementAlongLineSameSize
+      | CIMMarkerPlacementAlongLineVariableSize
+      | CIMMarkerPlacementAtExtremities
+      | CIMMarkerPlacementAtMeasuredUnits
+      | CIMMarkerPlacementAtRatioPositions
+      | CIMMarkerPlacementOnLine
+      | CIMMarkerPlacementOnVertices
+      | CIMMarkerPlacementInsidePolygon
+      | CIMMarkerPlacementPolygonCenter;
+    export type CIMSymbolType = CIMLineSymbol | CIMPointSymbol | CIMPolygonSymbol | CIMTextSymbol;
+    export type CIMGeometricEffectType =
+      | CIMGeometricEffectAddControlPoints
+      | CIMGeometricEffectArrow
+      | CIMGeometricEffectBuffer
+      | CIMGeometricEffectCut
+      | CIMGeometricEffectDashes
+      | CIMGeometricEffectDonut
+      | CIMGeometricEffectEnclosingPolygon
+      | CIMGeometricEffectExtension
+      | CIMGeometricEffectJog
+      | CIMGeometricEffectLocalizerFeather
+      | CIMGeometricEffectMove
+      | CIMGeometricEffectOffset
+      | CIMGeometricEffectOffsetHatch
+      | CIMGeometricEffectOffsetTangent
+      | CIMGeometricEffectRadial
+      | CIMGeometricEffectRegularPolygon
+      | CIMGeometricEffectReverse
+      | CIMGeometricEffectRotate
+      | CIMGeometricEffectScale
+      | CIMGeometricEffectSuppress
+      | CIMGeometricEffectTaperedPolygon
+      | CIMGeometricEffectWave;
+    export type CIMSymbolLayerType =
+      | CIMCharacterMarker
+      | CIMObjectMarker3D
+      | CIMPictureMarker
+      | CIMVectorMarker
+      | CIMGradientFill
+      | CIMHatchFill
+      | CIMPictureFill
+      | CIMSolidFill
+      | CIMGradientStroke
+      | CIMPictureStroke
+      | CIMSolidStroke
+      | CIMMaterialSymbolLayer;
+    export type CIMCalloutType = CIMLineCallout;
+
+    export interface ExternalReferencePoint {
+      x?: number;
+      y?: number;
+      z?: number;
+      m?: number;
+      spatialReference?: ExternalReferenceSpatialReference;
+    }
+
+    export interface ExternalReferencePolyline {
+      hasM?: boolean;
+      hasZ?: boolean;
+      paths?: number[][][];
+      curvePath?: number[][][];
+      spatialReference?: ExternalReferenceSpatialReference;
+    }
+
+    export interface ExternalReferencePolygon {
+      hasM?: boolean;
+      hasZ?: boolean;
+      rings?: number[][][];
+      curveRings?: number[][][];
+      spatialReference?: ExternalReferenceSpatialReference;
+    }
+
+    export interface ExternalReferenceEnvelope {
+      mmax?: number;
+      mmin?: number;
+      xmax?: number;
+      xmin?: number;
+      ymax?: number;
+      ymin?: number;
+      zmax?: number;
+      zmin?: number;
+      spatialReference?: ExternalReferenceSpatialReference;
+    }
+
+    export interface ExternalReferenceSpatialReference {
+      wkid?: number;
+      latestWkid?: number;
+      vcsWkid?: number;
+      latestVcsWkid?: number;
+    }
+
+    export type ExternalReferenceGeometry =
+      | ExternalReferencePoint
+      | ExternalReferencePolyline
+      | ExternalReferencePolygon
+      | ExternalReferenceEnvelope;
+  }
+    
+  export type EventHandlerCallback = (selectionResult: SelectionResultType) => void;
+  export type On = (eventName: string, eventHandler: EventHandlerCallback) => IHandle;
+}`;
+function gt(e, t) {
+  let i = yt;
+  for (let n = 0; n < e.length; ++n) {
+    const s = e[n];
+    i += ft(s, t);
+  }
+  return i + ht;
+}
+function vt(e, t, i) {
+  let n = "";
+  const s = t.importsMap, a = /* @__PURE__ */ Object.create(null);
+  for (const r in s) {
+    const o = s[r];
+    if (!o.wasUsed)
+      continue;
+    let l = o.specifier;
+    if (o.replacementName !== void 0) {
+      const d = s[o.replacementName];
+      if (d?.wasUsed === !0) {
+        d.specifier !== o.specifier && i.emitError(
+          `Failed to perform type replacement of ${r} with ${o.replacementName} because ${o.replacementName} is already imported from ${d.modulePath}, where as type replacement was going to import it from ${o.modulePath}. Either manually replace ${o.replacementName} usage with ${r} or alias ${r} to another name.`,
+          {
+            file: t.file,
+            node: void 0
+          }
+        );
+        continue;
+      }
+    }
+    const c = o.replacementName ?? r;
+    if (o.type === "named") {
+      if (o.modulePath !== void 0) {
+        const f = o.actualName ?? c, p = i.moduleMap.get(o.modulePath), g = p === void 0 ? void 0 : h(p);
+        if (g?.index.named[f] === void 0) {
+          if (i.privateMixinModuleNames.has(o.modulePath))
+            continue;
+          i.emitError(
+            `The ${x.red(f)} imported from ${x.red(p?.sourcePath ?? o.modulePath)} is not @public but used in the type of a @public declaration. Add /** @public */ JSDoc, refactor out the usage, or ensure ${x.red(f)} is not a re-export.`,
+            {
+              file: t.file,
+              node: void 0
+            }
+          );
+        } else
+          l = oe(g, t);
+      }
+      const d = a[l], m = o.actualName === void 0 ? c : `${o.actualName} as ${c}`;
+      a[l] = d === void 0 ? m : `${d}, ${m}`;
+    } else if (o.type === "default") {
+      if (o.modulePath !== void 0) {
+        const d = i.moduleMap.get(o.modulePath), m = d === void 0 ? void 0 : h(d);
+        m?.index.default === void 0 ? i.emitError(
+          `The default exported declaration in ${x.red(d?.sourcePath ?? o.modulePath)} is not @public but used in the type of a @public declaration. Add /** @public */ JSDoc or refactor out the usage.`,
+          {
+            file: t.file,
+            node: void 0
+          }
+        ) : l = oe(m, t);
+      }
+      n += `import type ${c} from "${l}";
+`;
+    } else {
+      if (o.modulePath !== void 0) {
+        const d = i.moduleMap.get(o.modulePath);
+        d === void 0 ? i.emitError(
+          `Non-public module was imported: ${x.red(o.modulePath)} and used in the type of a public declaration. Ensure the imported module has at least one /** @public */ declaration or refactor out the usage.`,
+          {
+            file: t.file,
+            node: void 0
+          }
+        ) : l = oe(h(d), t);
+      }
+      c === "__esri" ? n = `/// <reference types="@arcgis/core/interfaces.d.ts" />
+${n}` : n += `import type * as ${c} from "${l}";
+`;
+    }
+    if (o.modulePath !== void 0 && i.watchFiles !== void 0) {
+      const d = i.moduleMap.get(o.modulePath), f = (d === void 0 ? void 0 : h(d))?.file.fileName.slice(i.config.context.cwd.length);
+      f !== void 0 && (i.watchFiles.get(e.sourcePath).dependencies.add(f), i.watchFiles.get(f).dependents.set(e.sourcePath, !0));
+    }
+  }
+  if (i.produceDts) {
+    for (const r in a) {
+      const o = a[r];
+      n += `import type { ${o} } from "${r}";
+`;
+    }
+    t.importsText = n;
+  }
+}
+function oe(e, t) {
+  return `${be(t.dtsPath, e.dtsPath)}.js`;
+}
+function Ct(e, t, i, n) {
+  const s = e.references;
+  if (s !== void 0) {
+    if (t.autoCastingRequiresType === void 0 && s.length > 1 && s[0].module === "core/Collection")
+      if (s.length > 2)
+        t.autoCastingRequiresType = !0;
+      else {
+        const a = s[1], r = a.module === void 0 ? i : n.moduleMap.get(a.module), o = r === void 0 ? void 0 : h(r), l = a.name === "default" ? o?.index.default : o?.index.named[a.name];
+        $e(l) && (t.autoCastingRequiresType = !0);
+      }
+    return Ee(e, t, n, i, s);
+  }
+}
+function Ee(e, t, i, n, s) {
+  for (let a = s.length - 1; a >= 0; a--) {
+    const r = s[a];
+    if (r.package !== void 0) {
+      r.package === Ie && r.name === "Date" && he(
+        e,
+        s,
+        a,
+        { type: xt, inheritedFrom: void 0 },
+        i,
+        n,
+        t
+      );
+      continue;
+    }
+    const o = r.module === void 0 ? n : i.moduleMap.get(r.module), l = o === void 0 ? void 0 : h(o), c = r.name === "default" ? l?.index.default : l?.index.named[r.name];
+    if ($e(c)) {
+      const m = `(${c.type.text})`, f = e.text;
+      e.text = `${e.text.slice(0, r.start)}${m}${e.text.slice(r.end)}`;
+      const p = e.text, g = r.start + 1, u = [];
+      for (let C = 0; C < c.type.references.length; ++C) {
+        const y = c.type.references[C], b = y.module ?? o?.path, M = b === n.path;
+        u.push({
+          ...y,
+          module: M ? void 0 : b,
+          start: y.start + g,
+          end: y.end + g
+        });
+      }
+      if (Ee(e, t, i, n, u), e.text === p) {
+        e.text = f;
+        continue;
+      }
+      s.splice(a, 1, ...u);
+      const v = e.text.length - f.length;
+      xe(s, v, a + u.length);
+      continue;
+    }
+    if (c?.kind !== "class")
+      continue;
+    const d = Te(c, o, void 0, i);
+    if (d === void 0) {
+      i.emitError(
+        `Failed to resolve auto-castable type for ${x.red(c.name)} from ${x.red(o.sourcePath)}. Ensure the class either has a public constructor or a public ${x.green(c.name)}Properties interface. Auto-casting resolution was attempted because this class is used in an autocastable property in ${x.blue(
+          n.sourcePath
+        )} in type ${x.blue(e.text)}.`,
+        {
+          file: h(o).file,
+          node: void 0
+        }
+      );
+      continue;
+    }
+    he(
+      e,
+      s,
+      a,
+      d,
+      i,
+      n,
+      t
+    );
+  }
+}
+function Te(e, t, i, n) {
+  const s = h(t), a = s.constructorAutoCastType;
+  if (a !== void 0)
+    return a;
+  const r = Mt(e, t, i, n);
+  return r !== void 0 && (s.constructorAutoCastType = r), r;
+}
+function Mt(e, t, i, n) {
+  if (e.members !== void 0)
+    for (let r = 0; r < e.members.length; ++r) {
+      const o = e.members[r];
+      if (o.kind === "constructor" && // Use the last constructor for auto-casting signature
+      // Examples: Point, MeshTexture
+      e.members[r + 1]?.kind !== "constructor" && // Only consider the single-parameter signature
+      o.parameters?.length === 1 && // To avoid false positives, constructors without type references are not
+      // considered autocastable. This excludes core/Accessor#constructor's any[].
+      o.parameters[0].type?.references !== void 0)
+        return {
+          type: o.parameters[0].type,
+          inheritedFrom: i?.path
+        };
+    }
+  const a = h(t).constructorPropertiesInterface;
+  if (a !== void 0)
+    return { type: {
+      text: a.name,
+      references: [
+        {
+          name: a.name,
+          module: t.path,
+          package: void 0,
+          viewUrl: Xe(t.path, a.name, void 0, n),
+          start: 0,
+          end: a.name.length
+        }
+      ],
+      values: void 0,
+      source: void 0
+    }, inheritedFrom: i?.path };
+  if (e.superclass !== void 0) {
+    const r = e.superclass.module === void 0 ? t : n.moduleMap.get(e.superclass.module), c = (r === void 0 ? void 0 : h(r))?.index?.class;
+    if (c !== void 0)
+      return Te(c, r, r, n);
+  }
+}
+function he(e, t, i, { type: n, inheritedFrom: s }, a, r, o) {
+  let l = n.references;
+  l.length === 2 && l[0].name === "ReadonlyArrayOrCollection" && l[1].name === "T" && (l = [l[0]], n = {
+    ...n,
+    text: "ReadonlyArrayOrCollection",
+    references: l
+  });
+  let c = n.text;
+  const d = t[i], m = n.text.length - (d.end - d.start);
+  let f = 0;
+  t.splice(i, 1);
+  for (let p = l.length - 1; p >= 0; p--) {
+    const g = l[p], u = n.text.slice(g.start, g.end);
+    if (u !== g.name && g.name !== "default") {
+      a.emitError(
+        `Unsupported case: cannot yet handle auto-adding imports for renamed references. Tried to add ${g.name} as ${u} from ${g.module} when resolving auto-casting type.`,
+        {
+          file: h(r).file,
+          node: void 0
+        }
+      );
+      continue;
+    }
+    const v = g.module ?? s ?? d.module, C = (v === void 0 ? void 0 : a.moduleMap.get(v)) ?? r, y = h(C);
+    if (g.module === void 0 && g.package === void 0 && g.viewUrl === void 0) {
+      a.emitError(
+        `Unsupported case: auto-casting type for ${C.sourcePath} uses a type parameter. Failed to automatically turn \`${e.text}\` into an auto-castable type. Refactor out the type parameter, or submit API Extractor feature request to support this case.`,
+        {
+          file: h(r).file,
+          node: void 0
+        }
+      );
+      continue;
+    }
+    Fe(g, C, a, r);
+    const M = d.start, I = {
+      ...g,
+      start: g.start + M + f,
+      end: g.end + M + f
+    }, P = y.typeName;
+    if (l.length === 1 && o.autoCastingRequiresType === !0 && P !== void 0) {
+      const G = o.autoCastingDefaultType === P, S = `(${u} & { type${G ? "?" : ""}: "${P}" })`, F = S.length - u.length;
+      f += F, I.end += F, c = c.slice(0, g.start) + S + c.slice(g.end);
+    }
+    t.splice(i, 0, I);
+  }
+  return e.text = e.text.slice(0, d.start) + c + e.text.slice(d.end), xe(
+    t,
+    m + f,
+    i + (l?.length ?? 0)
+  ), !0;
+}
+function Fe(e, t, i, n) {
+  const s = h(n);
+  if (e.package !== void 0) {
+    if (e.package === Ie)
+      return;
+    i.emitError(
+      `Unsupported case: cannot yet handle auto-adding imports for external packages. Tried to add ${e.name} from ${e.package} when resolving auto-casting type.`,
+      {
+        file: s.file,
+        node: void 0
+      }
+    );
+  }
+  if (t === n)
+    return;
+  const a = h(t), r = e.name === "default" ? a.index.default?.name : e.name;
+  if (r === void 0) {
+    i.emitError(
+      `Failed to resolve the name of the default import from module ${t.sourcePath} when adding auto-casting import for ${e.name}.`,
+      {
+        file: s.file,
+        node: void 0
+      }
+    );
+    return;
+  }
+  let o = r, l;
+  const c = e;
+  c.printableText !== void 0 && (o = c.printableText, l = r);
+  const d = s.importsMap[o];
+  d === void 0 ? s.importsMap[o] = {
+    type: e.name === "default" ? "default" : "named",
+    modulePath: t.path,
+    specifier: be(s.dtsPath, a.dtsPath),
+    replacementName: void 0,
+    actualName: l,
+    wasUsed: !0
+  } : d.modulePath !== t.path ? i.emitError(
+    `API Extractor tried to add an import for ${e.name} from ${t.sourcePath}, but current module already imports ${e.name} from ${d.modulePath}. Please rename one of the types or use import alias to avoid the conflict`,
+    {
+      file: s.file,
+      node: void 0
+    }
+  ) : d.wasUsed = !0;
+}
+function $e(e) {
+  return e?.kind === "interface" && e.members === void 0 && e.supertypes === void 0 && e.type?.references !== void 0 && e.type.references.length > 1 && e.typeParameters === void 0 && bt(e.type);
+}
+function bt(e) {
+  let t = 0;
+  for (let i = 0; i < e.references.length; ++i) {
+    const n = e.references[i], s = e.text.slice(t, n.start).trim();
+    if (s !== "" && s !== "|")
+      return !1;
+    t = n.end;
+  }
+  return t === e.text.length;
+}
+const xt = {
+  // Wrap in parents to correctly substitute Date[] in TimeInfo.stops
+  text: "(Date | number | string)",
+  references: [
+    {
+      name: "Date",
+      module: void 0,
+      package: "global:",
+      viewUrl: "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Date",
+      start: 1,
+      end: 5
+    }
+  ],
+  values: void 0,
+  source: void 0
+};
+function Pt(e, t) {
+  const i = e.constructorPropertiesInterface;
+  i.type = void 0;
+  const n = K(i), s = h(t.apiModule).index.class;
+  if (i.typeParameters = s.typeParameters, s.superclass !== void 0) {
+    const r = ge(
+      s.superclass,
+      t,
+      K(s).superClassText
+    );
+    r !== void 0 && (n.superTypesText = [r.printableText ?? r.name]);
+  }
+  if (s.mixins !== void 0)
+    for (let r = 0; r < s.mixins.length; ++r) {
+      const o = s.mixins[r], l = ge(
+        o,
+        t,
+        o.printableText
+      );
+      l !== void 0 && (n.superTypesText ??= [], n.superTypesText.push(l.printableText ?? l.name));
+    }
+  let a = "";
+  if (s.members !== void 0)
+    for (let r = 0; r < s.members.length; ++r) {
+      const o = s.members[r];
+      if (o.kind !== "field" || o.inheritedFrom !== void 0 || o.static !== void 0)
+        continue;
+      const l = ne(o);
+      if (l.isAbstract)
+        continue;
+      let c = e.constructorOnlySetters?.[o.name];
+      if (c === void 0) {
+        if (o.readonly !== void 0)
+          continue;
+        if (o.getterType === void 0 && l.isOverride === void 0) {
+          a += `${a.length === 0 ? "" : " | "}"${o.name}"`;
+          continue;
+        } else
+          c = o.type, c.text.includes(" | undefined") || (c = { ...c, text: `${c.text} | undefined` });
+      } else c.text.includes(" | undefined") || (c.text += " | undefined");
+      const d = {
+        isAbstract: void 0,
+        isAccessor: void 0,
+        hasAutoCasting: void 0,
+        autoCastingRequiresType: void 0,
+        autoCastingDefaultType: void 0,
+        isConstructorOnly: void 0,
+        isOverride: void 0,
+        dtsTypeOverride: void 0
+      }, m = o, f = {
+        [et]: d,
+        kind: "field",
+        name: m.name,
+        static: void 0,
+        deprecated: m.deprecated,
+        summary: void 0,
+        description: m.description,
+        docsTags: m.docsTags,
+        type: c,
+        getterType: void 0,
+        default: m.default,
+        readonly: void 0,
+        inheritedFrom: void 0,
+        privacy: m.privacy,
+        source: void 0,
+        attribute: void 0,
+        reflects: void 0,
+        docsOnlyReadonly: void 0
+      };
+      i.members ??= [], i.members.push(f);
+    }
+  if (a.length > 0) {
+    n.superTypesText ??= [];
+    let r = `Partial<Pick<${s.name}`;
+    if (i.typeParameters !== void 0) {
+      r += "<";
+      for (let o = 0; o < i.typeParameters.length; ++o) {
+        const l = i.typeParameters[o];
+        r += l.name, o < i.typeParameters.length - 1 && (r += ", ");
+      }
+      r += ">";
+    }
+    r += `, ${a}>>`, n.superTypesText.push(r);
+  }
+}
+function ge(e, t, i) {
+  if (e.package !== void 0)
+    return;
+  const n = t.moduleMap.get(e.module), s = h(n), a = s.constructorPropertiesInterface;
+  if (a === void 0) {
+    const o = s.inheritance;
+    if (typeof o == "object" && o.hasSettableField) {
+      const l = e.name === "default" ? s.index.class?.name ?? e.name : e.name;
+      t.emitError(
+        `This file must have a @public ${x.green(`${l}Properties`)} interface because it contains a public class that has non-readonly public properties and it is being extended by ${t.apiModule.sourcePath}.`,
+        { file: h(t.apiModule).file, node: void 0 }
+      ), o.hasSettableField = !1;
+    }
+    return;
+  }
+  const r = {
+    name: a.name,
+    module: e.module,
+    package: e.package,
+    viewUrl: e.viewUrl,
+    typeArguments: void 0,
+    /**
+     * If class was renamed when imported, also rename the created Properties
+     * interface. This avoids name collision inside of
+     * views/3d/environment/SunLighting as it imports webscene/SunLighting.
+     * apiReference.name !== class.name for references to mixin base classes.
+     */
+    printableText: i === e.name ? void 0 : It(i, s.index.class.name)
+  };
+  return Fe(r, n, t, t.apiModule), r;
+}
+function It(e, t) {
+  if (e === void 0 || e === t)
+    return;
+  const i = e.indexOf("<");
+  if (e = i === -1 ? e : e.slice(0, i), e !== t)
+    return `${e}Properties`;
+}
+function St(e) {
+  if (e.customElement === void 0)
+    return;
+  const t = e, i = [];
+  for (let n = 0; n < t.members.length; ++n) {
+    const s = t.members[n];
+    if (s.kind !== "field" || s.attribute === void 0 || s.privacy !== void 0)
+      continue;
+    const a = s.type.values?.filter(
+      (r) => r.type === "number" || r.type === "string" || r.type === "boolean"
+    );
+    i.push({
+      name: s.attribute,
+      summary: s.summary,
+      description: s.description,
+      inheritedFrom: s.inheritedFrom,
+      type: a === void 0 || a.length === 0 ? s.type : {
+        text: Ge(a),
+        references: void 0,
+        values: a,
+        source: void 0
+      },
+      default: s.default,
+      fieldName: s.name,
+      deprecated: s.deprecated
+    });
+  }
+  i.length > 0 && (t.attributes = i);
+}
+const ce = {
+  /**
+   * Don't inherit or inheritance resolution failed.
+   */
+  skip: 0,
+  /**
+   * We already inherited the members, but have not yet computed the inheritance
+   * data for this module. Almost every class inherits some class, but only a
+   * few are inherited by other classes, so we compute inheritance data lazily.
+   */
+  deferred: 1
+};
+function kt(e, t, i, n) {
+  const s = e;
+  n.produceDts && (K(t).eventTypesProperty = s);
+  const a = h(i), r = `${t.name}Events`;
+  if (s.type.text !== r && !s.type.text.startsWith(`${r}<`)) {
+    if (s.type.text === "unknown")
+      return;
+    n.emitError(
+      `The "@eventTypes" property must be of type named "${t.name}Events". Found ${x.red(s.type.text)}.`,
+      {
+        file: a.file,
+        node: void 0
+      }
+    );
+    return;
+  }
+  const o = a.index.named[r];
+  if (o?.kind !== "interface") {
+    n.emitError(
+      `The "${r}" referenced by the "@eventTypes" property must be a @public interface and defined in the same file as the ${t.name} class.`,
+      {
+        file: a.file,
+        node: void 0
+      }
+    );
+    return;
+  }
+  t.events ??= [], Ae(o, t, i, void 0, n);
+}
+function Ae(e, t, i, n, s) {
+  const a = n !== void 0;
+  if (n ??= /* @__PURE__ */ new Set(), e.type !== void 0) {
+    s.emitError(
+      `For documentation purposes, event interface types need to be statically analyzable - include only properties & extends clauses. Found complex type in ${e.name}: ${e.type.text}`,
+      {
+        file: h(i).file,
+        node: void 0
+      }
+    );
+    return;
+  }
+  if (e.members !== void 0)
+    for (let r = 0; r < e.members.length; ++r) {
+      const o = e.members[r];
+      if (o.kind !== "field") {
+        s.emitError(
+          `Event interfaces should only contain properties. Found ${tt(o)} of kind ${x.red(o.kind)} in ${e.name}.`,
+          {
+            file: h(i).file,
+            node: void 0
+          }
+        );
+        continue;
+      }
+      n.has(o.name) || (n.add(o.name), t.events.push({
+        name: o.name,
+        deprecated: o.deprecated,
+        summary: void 0,
+        description: o.description,
+        docsTags: o.docsTags,
+        type: o.type,
+        inheritedFrom: a ? {
+          name: e.name,
+          module: i.path,
+          package: void 0,
+          viewUrl: void 0
+        } : void 0,
+        privacy: void 0,
+        bubbles: void 0,
+        cancelable: void 0,
+        composed: void 0
+      }));
+    }
+  if (e.supertypes !== void 0)
+    for (let r = 0; r < e.supertypes.length; ++r) {
+      const o = e.supertypes[r], l = o.module === void 0 ? i : s.moduleMap.get(o.module), c = h(l).index.named[o.name];
+      if (c?.kind !== "interface") {
+        s.emitError(
+          `Failed to find @public interface ${x.red(o.name)} (used by ${x.green(e.name)}).`,
+          {
+            file: h(i).file,
+            node: void 0
+          }
+        );
+        return;
+      }
+      Ae(c, t, l, n, s);
+    }
+}
+function we(e, t, i) {
+  const n = h(e);
+  if (n.inheritance !== void 0)
+    return;
+  n.inheritance = ce.deferred;
+  let a = !1;
+  if (t.members !== void 0)
+    for (let m = 0; m < t.members.length; ++m) {
+      const f = t.members[m];
+      if (f.kind === "field") {
+        if (f.name === "@eventTypes") {
+          a = !0, kt(f, t, e, i), t.members.splice(m, 1), m -= 1;
+          continue;
+        }
+        f.inheritedFrom === void 0 && Tt(f, e, i);
+      }
+    }
+  const r = t;
+  let o = t.mixins, l = r.superclass, c = l === void 0 ? void 0 : Me(l, e, i);
+  if (c?.supertypes !== void 0) {
+    o = o === void 0 ? [] : [...o];
+    do {
+      const m = c.supertypes.length > 1, f = m ? 1 : 0;
+      for (let p = c.supertypes.length - 1; p >= f; p--) {
+        const g = c.supertypes[p], u = g.module === void 0 ? { ...g, module: l.module } : g;
+        o.unshift(u);
+      }
+      l = m ? c.supertypes[0] : void 0, c = l === void 0 ? void 0 : Me(l, e, i);
+    } while (c?.supertypes !== void 0);
+  }
+  if (o !== void 0) {
+    const m = o.length - (t.mixins?.length ?? 0);
+    for (let f = o.length - 1; f >= 0; f--) {
+      const p = o[f], g = Ce(p.module ?? e.path, !0, i);
+      typeof g == "object" ? ve(g, t, a, i) : f >= m && (t.mixins.splice(f - m, 1), t.mixins.length === 0 && (t.mixins = void 0));
+    }
+  }
+  if (l?.package !== void 0)
+    return;
+  const d = l?.module;
+  if (d !== void 0) {
+    const m = Ce(d, !1, i);
+    typeof m == "object" && (m.declaration.privacy !== void 0 && t.privacy === void 0 && i.emitError(
+      `Public component may only subclass a public component to avoid broken inheritance. Tried to inherit from private ${m.declaration.name}. Remove @private from it but feel free to add a jsdoc description stating the base class is abstract - not for direct consumption. Lumina does bare minimum extraction work for private components, which makes them ineligible for public docs.`,
+      { file: n.file, node: void 0 }
+    ), ve(m, t, a, i));
+  }
+}
+function ve(e, t, i, n) {
+  const s = e.declaration, a = t;
+  if (e.indexedMembers !== void 0) {
+    t.members ??= [];
+    const r = t.members, o = n.config.documentation.noInheritMembers[e.inheritanceData.module];
+    let l = o === void 0 ? void 0 : new Set(o);
+    for (let d = 0; d < r.length; ++d) {
+      const m = r[d], f = le(m), p = e.indexedMembers[f];
+      if (p === void 0)
+        continue;
+      if (l ??= /* @__PURE__ */ new Set(), l.add(f), m.kind === "field") {
+        const u = ne(m);
+        ne(p).isAccessor === !0 && (u.isAccessor = !0), u.isOverride = !0;
+      }
+      p !== void 0 && m.inheritedFrom === void 0 && Se(p, m);
+    }
+    const c = s.members;
+    for (let d = 0; d < c.length; ++d) {
+      const m = c[d];
+      // Most classes don't override any public members, so don't even check
+      // for this if no members were overridden.
+      (l?.has(le(m)) ?? !1) || t.members.push(
+        m.inheritedFrom === void 0 ? { ...m, inheritedFrom: e.inheritanceData } : m
+      );
+    }
+  }
+  !i && e.indexedEvents !== void 0 && (a.events = V(
+    a.events,
+    s.events,
+    e.indexedEvents,
+    e.inheritanceData
+  )), e.indexedAttributes !== void 0 && (a.attributes = V(
+    a.attributes,
+    s.attributes,
+    e.indexedAttributes,
+    e.inheritanceData
+  )), e.indexedSlots !== void 0 && (a.slots = V(
+    a.slots,
+    s.slots,
+    e.indexedSlots
+  )), e.indexedCssParts !== void 0 && (a.cssParts = V(
+    a.cssParts,
+    s.cssParts,
+    e.indexedCssParts
+  )), e.indexedCssProperties !== void 0 && (a.cssProperties = V(
+    a.cssProperties,
+    s.cssProperties,
+    e.indexedCssProperties
+  )), e.indexedCssStates !== void 0 && (a.cssStates = V(
+    a.cssStates,
+    s.cssStates,
+    e.indexedCssStates
+  ));
+}
+function V(e = [], t, i, n) {
+  const s = /* @__PURE__ */ new Set();
+  for (let a = 0; a < e.length; ++a) {
+    const r = e[a], o = i[r.name];
+    o !== void 0 && (s.add(r.name), r.inheritedFrom === void 0 && Se(o, r));
+  }
+  for (let a = 0; a < t.length; ++a) {
+    const r = t[a];
+    s.has(r.name) || e.push(
+      n === void 0 || r.inheritedFrom !== void 0 ? r : { ...r, inheritedFrom: n }
+    );
+  }
+  return e;
+}
+function Ce(e, t, i) {
+  const n = i.moduleMap.get(e), s = Et(n, e, t, i), a = n === void 0 ? void 0 : h(n);
+  if (s === !1 || n === void 0)
+    return a !== void 0 ? a.inheritance = ce.skip : t && i.privateMixinModuleNames.add(e), ce.skip;
+  const [r, o] = s, l = o;
+  we(n, o, i);
+  let c, d = !1;
+  if (o.members !== void 0) {
+    c = /* @__PURE__ */ Object.create(null);
+    for (let f = 0; f < o.members.length; ++f) {
+      const p = o.members[f], g = le(p), v = c[g] !== void 0;
+      c[g] = v ? void 0 : p, d ||= p.kind === "field" && p.readonly === void 0;
+    }
+  }
+  const m = {
+    inheritanceData: {
+      name: o.name,
+      module: r,
+      package: void 0,
+      viewUrl: void 0
+    },
+    declaration: o,
+    hasSettableField: d,
+    indexedMembers: c,
+    indexedEvents: X(o.events),
+    indexedAttributes: X(l.attributes),
+    indexedSlots: X(l.slots),
+    indexedCssParts: X(l.cssParts),
+    indexedCssProperties: X(l.cssProperties),
+    indexedCssStates: X(l.cssStates)
+  };
+  return a.inheritance = m, m;
+}
+function X(e) {
+  if (e === void 0)
+    return;
+  const t = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < e.length; ++i) {
+    const n = e[i];
+    t[n.name] = n;
+  }
+  return t;
+}
+function Et(e, t, i, n) {
+  const s = e === void 0 ? void 0 : h(e), a = s?.index.class;
+  return a === void 0 ? (i || n.emitError(
+    `Failed to find @public class/custom element declaration in ${x.red(t)}. Referenced in the extends clause by ${x.blue(n.apiModule.sourcePath)}`,
+    {
+      file: s?.file,
+      scope: s === void 0 ? t : void 0,
+      node: void 0
+    }
+  ), !1) : [t, a];
+}
+function Me(e, t, i) {
+  if (e.package !== void 0)
+    return;
+  const n = e.module === void 0 ? t : i.moduleMap.get(e.module), s = n === void 0 ? void 0 : h(n), a = e.name === "default" ? s?.index.default : s?.index.named[e.name];
+  if (a === void 0) {
+    i.emitError(
+      `Failed to find @public class/mixin/custom element declaration in ${x.red(n?.sourcePath ?? e.module ?? t.sourcePath)}. Referenced in the extends clause by ${x.blue(t.sourcePath)}.`,
+      {
+        file: s?.file,
+        scope: n === void 0 ? t.path : void 0,
+        node: void 0
+      }
+    );
+    return;
+  }
+  return a.kind === "interface" ? a : void 0;
+}
+function Tt(e, t, i) {
+  const n = ne(e), s = h(t);
+  n.hasAutoCasting === !0 && (Ct(e.type, n, t, i), n.isConstructorOnly !== !0 && e.getterType?.text === e.type.text && (e.getterType = void 0)), n.isConstructorOnly === !0 && (s.constructorOnlySetters ??= {}, s.constructorOnlySetters[e.name] = e.type, e.type = e.getterType ?? e.type, e.getterType = void 0, e.readonly = !0);
+}
+function Ft(e, t, i) {
+  if (!(i.watchFiles === void 0 || t.reExports === void 0))
+    for (let n = 0; n < t.reExports.length; ++n) {
+      const s = t.reExports[n];
+      if (s.modulePath === void 0)
+        continue;
+      const a = i.moduleMap.get(s.modulePath), o = (a === void 0 ? void 0 : h(a))?.file.fileName.slice(i.config.context.cwd.length);
+      o !== void 0 && (i.watchFiles.get(e.sourcePath).dependencies.add(o), i.watchFiles.get(o).dependents.set(e.sourcePath, !0));
+    }
+}
+function $t(e, t) {
+  e.sort(it), At(e, t), t.isComponentProject && Le(e, t);
+}
+function At(e, t) {
+  for (let i = 0; i < e.length; ++i) {
+    const n = e[i];
+    if (!h(n).isStale)
+      continue;
+    t.apiModule = n;
+    const a = n.deprecated !== void 0;
+    for (let r = 0; r < n.declarations.length; ++r) {
+      const o = n.declarations[r];
+      a && o.deprecated === void 0 && t.emitError(
+        `If module is marked as @deprecated, all its declarations must be too. Found non-deprecated ${o.name}`,
+        {
+          file: h(n).file,
+          node: void 0
+        }
+      ), "members" in o && o.kind !== "interface" && (we(n, o, t), o.events?.sort(nt));
+    }
+  }
+  for (let i = 0; i < e.length; ++i) {
+    const n = e[i], s = h(n);
+    if (!s.isStale) {
+      const a = t.watchFiles?.get(n.sourcePath);
+      if (a?.hasDirtyLinks === !0) {
+        t.apiModule = n;
+        for (let r = 0; r < a.docLinks.length; ++r) {
+          const o = a.docLinks[r];
+          t.resolveJsDocLink(`{@link ${o}}`, o);
+        }
+        a.hasDirtyLinks = !1;
+      }
+      continue;
+    }
+    t.apiModule = n, t.inheritedModuleName = void 0, n.deprecated = Q(n.deprecated, t), n.description = D(n.description, t), J(n.docsTags, t);
+    for (let a = 0; a < n.declarations.length; ++a) {
+      const r = n.declarations[a];
+      if (r.deprecated = Q(r.deprecated, t), r.description = D(r.description, t), J(r.docsTags, t), r.kind === "function") {
+        if (r.parameters !== void 0)
+          for (let l = 0; l < r.parameters.length; ++l) {
+            const c = r.parameters[l];
+            c.description = D(c.description, t), J(c.docsTags, t);
+          }
+        r.return !== void 0 && (r.return.description = D(r.return.description, t));
+      }
+      const o = r;
+      if (o.members !== void 0) {
+        for (let c = 0; c < o.members.length; ++c) {
+          const d = o.members[c], m = d.inheritedFrom, f = m !== void 0;
+          if (t.inheritedModuleName = m?.module, d.deprecated = Q(d.deprecated, t), d.description = D(d.description, t), J(d.docsTags, t), !f && d.kind !== "field") {
+            if (d.parameters !== void 0)
+              for (let g = 0; g < d.parameters.length; ++g) {
+                const u = d.parameters[g];
+                u.description = D(u.description, t), J(u.docsTags, t);
+              }
+            const p = d;
+            p.return !== void 0 && (p.return.description = D(p.return.description, t));
+          }
+          t.inheritedModuleName = void 0;
+        }
+        (r.kind !== "interface" || t.isJsApi) && o.members.sort(ot);
+        const l = r;
+        if (l.events !== void 0) {
+          for (let c = 0; c < l.events.length; ++c) {
+            const d = l.events[c];
+            t.inheritedModuleName = d.inheritedFrom?.module, d.deprecated = Q(d.deprecated, t), d.description = D(d.description, t), J(d.docsTags, t);
+          }
+          t.inheritedModuleName = void 0;
+        }
+        if (t.config.context.isLuminaMinimalExtraction || St(o), l.slots !== void 0)
+          for (let c = 0; c < l.slots.length; ++c) {
+            const d = l.slots[c];
+            d.description = D(d.description, t);
+          }
+        if (l.cssProperties !== void 0)
+          for (let c = 0; c < l.cssProperties.length; ++c) {
+            const d = l.cssProperties[c];
+            d.description = D(d.description, t);
+          }
+        if (l.cssParts !== void 0)
+          for (let c = 0; c < l.cssParts.length; ++c) {
+            const d = l.cssParts[c];
+            d.description = D(d.description, t);
+          }
+        if (l.cssStates !== void 0)
+          for (let c = 0; c < l.cssStates.length; ++c) {
+            const d = l.cssStates[c];
+            d.description = D(d.description, t);
+          }
+        if (l.demos !== void 0)
+          for (let c = 0; c < l.demos.length; ++c) {
+            const d = l.demos[c];
+            d.description = D(d.description, t);
+          }
+      } else r === s.constructorPropertiesInterface && (n.declarations.splice(a, 1), a -= 1);
+    }
+    s.constructorPropertiesInterface !== void 0 && Pt(s, t), vt(n, s, t), Ft(n, s, t);
+  }
+}
+const wt = async function() {
+  if (this.isRunInProgress)
+    throw Error(
+      "The ApiExtractor.run() is already in progress, or previous run crashed with unrecoverable error. Await the previous run first or create a new ApiExtractor"
+    );
+  this.isRunInProgress = !0, this.errorCount = 0, this.silencedBrokenLinkCount = 0;
+  const e = this.config;
+  this.watchFiles === void 0 && (this.moduleMap = /* @__PURE__ */ new Map());
+  const t = e.context.dtsEmitPath !== "", i = e.context.emptyDtsEmitPath && t ? (
+    // This takes 80ms for JSAPI
+    Oe(e.context.dtsEmitPath)
+  ) : void 0;
+  if (e.types.typeCheckedExtraction || e.types.fullTypeCheck) {
+    const o = Z(), l = e.types.typeScriptConfig;
+    if (this.watchFiles === void 0) {
+      const c = k.createCompilerHost(l.config.options), d = k.createProgram({
+        host: c,
+        rootNames: l.config.fileNames,
+        options: l.config.options,
+        projectReferences: l.config.projectReferences
+      });
+      this.program = d, e.types.typeScriptInstanceCreated(d, c);
+    }
+    De(this, o);
+  }
+  const n = Z(), s = await Ne(this);
+  $t(s, this);
+  const a = this.wrapApiModules(s);
+  e.context.logger.info(
+    `${j}Extracted ${s.length} @public files in ${x.green(`${n()}s`)}`
+  );
+  const r = { apiJson: a, dtsFiles: void 0 };
+  if (e.afterApiJsonCreate !== ke && e.afterApiJsonCreate(r), this.produceDts) {
+    const o = Z(), l = this.dtsFiles;
+    if (this.dtsFiles = /* @__PURE__ */ new Map(), this.isJsApi) {
+      const c = gt(s, this), d = `${e.context.dtsEmitPath}interfaces.d.ts`;
+      this.dtsFiles.set(d, c);
+    } else this.isComponentProject && Be(s, this);
+    for (let c = 0; c < s.length; ++c) {
+      const d = s[c], m = h(d);
+      let f = `${e.context.dtsEmitPath + m.dtsPath}.d.ts`, p;
+      if (m.isStale) {
+        if (p = We(d, this), e.types.declarationTextTransformers.length > 0) {
+          let v = { filePath: f, content: p };
+          for (let C = 0; C < e.types.declarationTextTransformers.length; ++C) {
+            const y = e.types.declarationTextTransformers[C];
+            if (v = y(v, d, this), v === !1)
+              break;
+          }
+          if (v === !1)
+            continue;
+          f = v.filePath, p = v.content;
+        }
+      } else
+        p = l.get(f);
+      if (d.exports?.[0].kind === "custom-element-definition" && p.length > 0) {
+        const v = `${f.slice(0, -19)}/index.d.ts`;
+        this.dtsFiles.set(v, 'export * from "./customElement.js";');
+      }
+      this.dtsFiles.set(f, p);
+    }
+    if (this.changedDtsFiles !== void 0)
+      for (const [c, d] of this.dtsFiles)
+        l.get(c) !== d && this.changedDtsFiles.set(c, d);
+    if (t) {
+      await i, await se(e.context.dtsEmitPath, { recursive: !0 }), await Dt(e.context.dtsEmitPath, !0, this.changedDtsFiles ?? this.dtsFiles);
+      const c = O.join(O.relative(process.cwd(), e.context.dtsEmitPath), "/");
+      e.context.logger.info(
+        `${j}Wrote ${c}**/*${x.blue(".d.ts")} in ${x.green(`${o()}s`)}`
+      );
+    }
+  }
+  if (e.context.apiJsonEmitPath !== "") {
+    const o = O.resolve(e.context.cwd, e.context.apiJsonEmitPath), l = O.join(O.relative(process.cwd(), O.dirname(o)), "/");
+    await se(O.dirname(o), { recursive: !0 }), await Pe(
+      o,
+      e.context.environment === "production" ? JSON.stringify(a) : JSON.stringify(a, null, 2)
+    ), e.context.logger.info(
+      `${j}Wrote ${l}${x.yellow(O.basename(o))}`
+    );
+  }
+  return this.typeVerifier?.verifyTypes(s), this.errorCount > 0 && e.context.logger.error(
+    `${j}${x.red(`Found ${this.errorCount} ${this.errorCount === 1 ? "error" : "errors"}`)}`
+  ), this.silencedBrokenLinkCount > 0 && e.context.logger.info(`${j}Silenced ${this.silencedBrokenLinkCount} broken link errors.`), this.isRunInProgress = !1, this.produceDts && (r.dtsFiles = this.dtsFiles), r;
+};
+async function Dt(e, t, i) {
+  const n = /* @__PURE__ */ new Set(), s = Array.from(i.entries());
+  for (let l = 0; l < s.length; ++l) {
+    const [c, d] = s[l];
+    if (d.length === 0)
+      continue;
+    const m = (t ? c.slice(e.length) : c).split("/");
+    for (let f = 1; f < m.length; ++f)
+      n.add(m.slice(0, f).join("/"));
+  }
+  const a = new Array(n.size);
+  for (const l of n)
+    a.push(se(e + l, { recursive: !0 }));
+  await Promise.all(a);
+  const r = new Array(s.length), o = t ? "" : e;
+  for (let l = 0; l < s.length; ++l) {
+    const [c, d] = s[l];
+    if (d.length === 0)
+      continue;
+    const m = o + c;
+    r[l] = Pe(m, d);
+  }
+  await Promise.all(r);
+}
+function De(e, t) {
+  if (e.config.types.fullTypeCheck)
+    if ("getSemanticDiagnostics" in e.program) {
+      const i = e.builderProgram === void 0 ? k.getPreEmitDiagnostics(e.program) : e.builderProgram.getSemanticDiagnostics();
+      i.length > 0 && (e.config.context.logger.error(
+        k.formatDiagnosticsWithColorAndContext(i, re)
+      ), e.errorCount += i.length, process.exitCode = 1), e.config.types.afterDiagnostic(i), e.config.context.logger.info(`${j}Type checked in ${Ze("cyan", `${t()}s`)}`);
+    } else
+      e.emitError("Can't do type checking as the passed ts.Program is not a ts.Program instance.", {
+        file: void 0,
+        node: void 0
+      });
+}
+const Rt = async function() {
+  if (this.watchFiles !== void 0)
+    throw Error(
+      "The ApiExtractor.watch() is already in progress, or previous watch crashed with unrecoverable error. Stop the previous watch first or create a new ApiExtractor"
+    );
+  this.watchFiles = /* @__PURE__ */ new Map(), this.moduleMap = /* @__PURE__ */ new Map();
+  const e = this.config;
+  let t;
+  const i = /* @__PURE__ */ new Map();
+  let n = [];
+  const s = (u, v, C) => {
+    r(u), o(v, C, u.previousModule);
+  }, a = (u, v) => {
+    this.watchFiles.delete(v), u.module !== void 0 && n.push(u.module), r(u);
+  }, r = (u) => {
+    if (u.module === void 0)
+      return;
+    const v = u.module;
+    this.moduleMap.delete(v.path), u.previousModule = u.module, u.module = void 0, u.isEmptyModule = !1;
+    for (const C of u.dependencies)
+      this.watchFiles.get(C)?.dependents.delete(v.sourcePath);
+    for (const [C, y] of u.dependents) {
+      const b = this.watchFiles.get(C);
+      b !== void 0 && (y ? (b.dependencies.delete(v.sourcePath), r(b)) : b.hasDirtyLinks = !0);
+    }
+  }, o = (u, v, C) => {
+    if (v === void 0) {
+      const y = e.context.cwd + u, b = ct(y, "utf8");
+      v = He(y, b);
+    }
+    this.watchFiles.set(u, {
+      file: v,
+      module: void 0,
+      previousModule: C,
+      isEmptyModule: !1,
+      dependencies: /* @__PURE__ */ new Set(),
+      dependents: /* @__PURE__ */ new Map(),
+      docLinks: [],
+      hasDirtyLinks: !1,
+      wasRemoved: !1
+    });
+  };
+  let l, c = !0, d;
+  m();
+  function m() {
+    return d === void 0 ? (d = Promise.withResolvers(), e.watch.onUpdate(d.promise), !0) : !1;
+  }
+  function f(u) {
+    d?.resolve(u), d = void 0;
+  }
+  const p = async () => {
+    this.changedDtsFiles = e.watch.skipWritingUnchanged && this.dtsFiles.size > 0 ? /* @__PURE__ */ new Map() : void 0;
+    let u;
+    try {
+      u = await this.run();
+    } catch (M) {
+      throw f(void 0), M;
+    }
+    const v = [], C = [];
+    for (const M of this.watchFiles.values()) {
+      const I = M.module, P = M.previousModule;
+      if (I === void 0)
+        P !== void 0 && (M.module = M.previousModule, a(M, P.sourcePath));
+      else {
+        P === void 0 ? (c || C.push(I), M.previousModule = I) : I !== P && (Je(I, P) ? M.module = P : (v.push({ old: P, new: I }), M.previousModule = I));
+        const G = h(I);
+        G.isStale && (G.isStale = !1);
+      }
+    }
+    this.program ??= {
+      getSourceFiles: () => {
+        const M = [];
+        for (const I of this.watchFiles.values())
+          M.push(I.file);
+        return M;
+      },
+      getSourceFile: (M) => this.watchFiles.get(M.slice(e.context.cwd.length))?.file
+    };
+    const y = {
+      apiJson: u.apiJson,
+      dtsFiles: u.dtsFiles,
+      changedModules: v,
+      addedModules: C,
+      removedModules: n
+    };
+    n = [];
+    const b = c || v.length > 0 || C.length > 0 || y.removedModules.length > 0;
+    c = !1, f(b ? y : void 0), l?.();
+  };
+  if (e.types.typeCheckedExtraction || e.types.fullTypeCheck) {
+    const u = e.types.fullTypeCheck ? k.createSemanticDiagnosticsBuilderProgram : k.createAbstractBuilder;
+    let v;
+    const C = (S, F, E, ...A) => (v = E, u(
+      // If not doing full type check, don't scout test files
+      // If non-tests import tests, they will be included implicitly anyway
+      e.types.fullTypeCheck ? S : S?.filter((T) => !je(T)),
+      F,
+      E,
+      ...A
+      // Type cast to keep types simpler&aligned between two branches
+    )), y = k.createWatchCompilerHost(
+      // This parses the config file again (we already do it) and computes the
+      // files include array, however avoiding this is tricky, and overhead is small.
+      e.types.typeScriptConfigPath,
+      void 0,
+      k.sys,
+      C,
+      void 0,
+      void 0
+    ), b = y.setTimeout;
+    let M;
+    y.setTimeout = b === void 0 ? void 0 : (S, F, ...E) => {
+      if (!(E[0] === "timerToUpdateProgram"))
+        return b(S, F, ...E);
+      const w = M !== void 0 ? Promise.resolve() : d === void 0 ? Promise.resolve(m()) : d.promise.finally(m);
+      return M = b(
+        (...H) => {
+          M = void 0, w.finally(() => {
+            this.program = void 0, S(...H), this.program === void 0 && f(void 0);
+          });
+        },
+        e.watch.debounceTime,
+        ...E
+      ), M;
+    };
+    const I = y.onWatchStatusChange, P = 6031, G = 6032;
+    y.onWatchStatusChange = (S, ...F) => {
+      S.code === G ? e.watch.clearScreen && k.sys.clearScreen?.() : S.code !== P && I?.(S, ...F);
+    }, y.afterProgramCreate = (S) => {
+      this.builderProgram = S;
+      const F = S.getProgram();
+      this.program = F;
+      const E = F.getSourceFiles();
+      e.types.typeScriptInstanceCreated(F, v);
+      for (const T of this.watchFiles.values())
+        T.wasRemoved = !0;
+      let A = !1;
+      for (let T = 0; T < E.length; ++T) {
+        const w = E[T];
+        if (!fe(w.fileName, this))
+          continue;
+        const U = w.fileName.slice(e.context.cwd.length), H = this.watchFiles.get(U);
+        H === void 0 ? (o(U, w, void 0), A = !0) : H.file !== w ? (s(H, U, w), A = !0) : H.wasRemoved = !1;
+      }
+      for (const [T, w] of this.watchFiles)
+        w.wasRemoved && (a(w, T), A = !0);
+      A ? p() : (De(this, Z()), f(void 0));
+    }, t = k.createWatchProgram(y);
+  } else {
+    let u = function(y) {
+      return dt(y, {
+        throwIfNoEntry: !1
+      })?.isFile();
+    };
+    const v = st(() => {
+      let y = !1;
+      for (const [b, M] of i)
+        y = C(b, M) || y;
+      i.clear(), y ? (e.watch.clearScreen && k.sys.clearScreen?.(), p()) : f(void 0);
+    }, e.watch.debounceTime), C = (y, b) => {
+      const M = e.context.cwd + y, I = !b, P = this.watchFiles.get(y), G = P !== void 0;
+      if (I || P === void 0) {
+        const S = u(M);
+        if (S === !1) {
+          let E, A = !1;
+          try {
+            E = at(M, { recursive: !0 });
+            let T;
+            for (; (T = E.readSync()) !== null; ) {
+              if (T.isDirectory())
+                continue;
+              const U = `${T.parentPath}/${T.name}`.slice(e.context.cwd.length);
+              ze(U) && (A = C(U, !1) || A);
+            }
+          } finally {
+            E?.closeSync();
+          }
+          return A;
+        }
+        const F = S === !0;
+        if (G) {
+          if (F)
+            return s(P, y, void 0), !0;
+          {
+            const E = P?.module !== void 0;
+            return a(P, y), E;
+          }
+        } else {
+          if (F)
+            return o(y, void 0, void 0), !0;
+          {
+            let E = !1;
+            const A = `${y}/`;
+            for (const [T, w] of this.watchFiles)
+              T.startsWith(A) && (a(w, T), E = !0);
+            return E;
+          }
+        }
+      } else
+        return s(P, y, void 0), !0;
+    };
+    t = lt(this.basePath, { recursive: !0 }, (y, b) => {
+      const M = m(), I = b === null ? void 0 : qe(b), P = y === "change";
+      if (I !== void 0 && // If changed, check if it is an included file
+      // For a rename, we don't know if it is directory or a file - only check
+      // if directory is included, and the file will be checked later.
+      (P ? fe(this.basePath + I, this) : Ue(this.basePath + I, this))) {
+        const G = e.context.basePath + I, F = (i.get(G) ?? !0) && P;
+        i.set(G, F);
+      }
+      M && v();
+    }), p(), l = () => {
+      i.size > 0 && v();
+    };
+  }
+  return {
+    close: async () => {
+      t.close(), i.clear(), await d?.promise, this.watchFiles = void 0;
+    }
+  };
+}, Gt = ".verify-typings.ts";
+class Lt {
+  constructor(t, i = O.join(process.cwd(), "dist")) {
+    this.extractor = t, this.virtualCwdPath = O.join(i, "/");
+  }
+  verifyTypes(t) {
+    const i = Z(), n = /* @__PURE__ */ Object.create(null);
+    n[this.virtualCwdPath + Gt] = this.getVerificationFileContents(t);
+    const s = this.extractor.config.context.dtsEmitPath === "" ? this.virtualCwdPath : "";
+    for (const [f, p] of this.extractor.dtsFiles)
+      n[s + f] = p;
+    const a = {
+      lib: ["lib.dom.d.ts", "lib.esnext.d.ts"],
+      module: k.ModuleKind.ESNext,
+      // Our dependencies' typings are not yet moduleResolution:Node16 compatible
+      moduleResolution: k.ModuleResolutionKind.Bundler,
+      target: k.ScriptTarget.ESNext,
+      noPropertyAccessFromIndexSignature: !0,
+      noUncheckedIndexedAccess: !0,
+      noImplicitOverride: !0,
+      skipDefaultLibCheck: !0,
+      strict: !0,
+      verbatimModuleSyntax: !0,
+      esModuleInterop: !0,
+      declaration: !0,
+      // Performance optimization. Don't auto-load node_modules/@types
+      types: [],
+      // Performance optimization. Don't look up node_modules/@typescript/lib-...
+      libReplacement: !1
+    }, r = k.createCompilerHost(a), o = r.fileExists;
+    r.fileExists = (f) => f.endsWith("package.json") ? f.includes("node_modules") ? o(f) : !1 : n[f] !== void 0 ? !0 : f.endsWith(".d.ts") ? o(f) : !1, r.useCaseSensitiveFileNames = () => !0;
+    const l = r.readFile;
+    r.readFile = (f) => {
+      const p = n[f];
+      return p === void 0 ? l(f) : p;
+    };
+    const c = r.directoryExists;
+    r.directoryExists = (f) => f.includes("node_modules") ? c(f) : !0, r.getCurrentDirectory = () => this.virtualCwdPath, r.getCanonicalFileName = re.getCanonicalFileName;
+    const d = k.createProgram({
+      rootNames: Object.keys(n),
+      host: r,
+      options: a
+    }), m = k.getPreEmitDiagnostics(d).filter(this.extractor.config.verify.filterTypeCheckDiagnostic);
+    m.length && (this.extractor.config.context.logger.error(
+      k.formatDiagnosticsWithColorAndContext(m, re)
+    ), process.exitCode = 1, this.extractor.errorCount += m.length), this.extractor.config.context.logger.info(`${j}Types verified in ${x.green(`${i()}s`)}`);
+  }
+  printTypeParameters(t, i) {
+    if (t === void 0)
+      return "";
+    let n = "";
+    for (let s = 0; s < t.length; ++s) {
+      const a = t[s];
+      if (a.default !== void 0)
+        break;
+      n === "" ? n += "<" : n += ", ", n += a.constraint === void 0 ? "any" : ae(a.constraint, i).text;
+    }
+    return n === "" ? "" : `${n}>`;
+  }
+  getVerificationFileContents(t) {
+    let i = `declare const $: unknown;
+
+`;
+    for (let n = 0; n < t.length; ++n) {
+      const s = t[n], a = h(s);
+      if (a.constructorPropertiesInterface !== void 0) {
+        const r = a.constructorPropertiesInterface.name, o = this.printTypeParameters(
+          a.constructorPropertiesInterface.typeParameters,
+          s.path
+        ), l = r.slice(0, -10), c = s.exports === void 0 ? l : "default";
+        i += `$ as import("./${s.path}.js").${c}${o} satisfies import("./${s.path}.js").${r}${o};
+`;
+      }
+    }
+    return i;
+  }
+}
+class _t {
+  /**
+   * @public
+   * @param rawConfig Optional configuration for the extractor.
+   */
+  constructor(t = {}) {
+    this.componentStories = /* @__PURE__ */ Object.create(null), this.dtsFiles = /* @__PURE__ */ new Map(), this.changedDtsFiles = void 0, this.isRunInProgress = !1, this.watchFiles = void 0, this.program = void 0, this.builderProgram = void 0, this.componentPathMapping = void 0, this.componentCssFileDocs = void 0, this.vanillaComponentTypes = void 0, this.isInLuminaMinimalExtraction = !1, this.errorCount = 0, this.silencedBrokenLinkCount = 0, this.loggedBooleanWarning = !1, this.moduleMap = void 0, this.privateMixinModuleNames = /* @__PURE__ */ new Set(), this.implicitPublicModules = void 0, this.file = void 0, this.apiModule = void 0, this.componentTagName = void 0, this.pairedSetter = void 0, this.statementJsDocs = [], this.jsDoc = void 0, this.apiObject = void 0, this.moduleContext = void 0, this.localDeclarations = /* @__PURE__ */ new Set(), this.exportDefaultName = void 0, this.objectLikeTypeParameters = void 0, this.functionLikeTypeParameters = void 0, this.apiClassLikeName = void 0, this.mixinName = void 0, this.mixinMixins = void 0, this.moduleHasAccessorLikeClass = !1, this.moduleHasClass = !1, this.inheritedModuleName = void 0, this.run = wt.bind(this), this.watch = Rt.bind(this), this.emitError = Re.bind(this);
+    const i = Ve(t);
+    this.config = i, this.config.context.environment === "production" ? (this.normalizedDocumentationHost = me, this.alternativeDocumentationHost = pe) : (this.normalizedDocumentationHost = pe, this.alternativeDocumentationHost = me), this.produceDts = i.types.forceProduceDts || i.context.dtsEmitPath !== "" || i.verify.typeCheckTypes, this.basePath = `${i.context.cwd}${i.context.basePath}`, this.normalizedApiReferencePrefix = `https://${this.normalizedDocumentationHost}/javascript/latest/api-reference/esri-`, this.runtimeDependencyNames = /* @__PURE__ */ new Set([
+      ...Object.keys(i.context.packageJson.dependencies ?? {}),
+      ...Object.keys(i.context.packageJson.peerDependencies ?? {})
+    ]), this.resolveJsDocLink = i.context.isLuminaMinimalExtraction ? ke : Ye.bind(void 0, this), this.isComponentProject = "@arcgis/lumina" in (i.context.packageJson.dependencies ?? {}), this.isJsApi = i.context.packageJson.name === "arcgis-js-api", this.typeVerifier = i.verify.typeCheckTypes ? new Lt(this, i.context.dtsEmitPath || void 0) : void 0, this.localPrivateDeclarations = i.strict ? void 0 : /* @__PURE__ */ new Map();
+  }
+  /**
+   * Given an array of ApiModules, add top-level api.json metadata and return
+   * the completed ApiJson structure.
+   */
+  wrapApiModules(t) {
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString().split(".")[0],
+      compiler: {
+        // Preserve previous compiler.name for component projects as that is what
+        // pre 5.0 Lumina versions expect.
+        name: this.isComponentProject ? "@arcgis/lumina-compiler" : de.name,
+        version: de.version,
+        typescriptVersion: k.version
+      },
+      // https://github.com/webcomponents/custom-elements-manifest?tab=readme-ov-file#schema-versioning
+      // https://github.com/webcomponents/custom-elements-manifest/releases
+      schemaVersion: "2.1.0",
+      readme: void 0,
+      deprecated: void 0,
+      modules: t
+    };
+  }
+}
+export {
+  _t as A,
+  Dt as w
+};