import*as e from"../third_party/lit-html/lit-html.js";import{Directives as t}from"../third_party/lit-html/lit-html.js";import{ls as s,SimpleHistoryManager as r}from"../common/common.js";import{Widget as n,TabbedPane as o}from"../ui/ui.js";function i(e,t){return e.toString(16).padStart(t,"0").toUpperCase()}var a=Object.freeze({__proto__:null,toHexString:i});const{render:l,html:d}=e;class c extends Event{constructor(e){super("page-navigation",{}),this.data=e}}class h extends Event{constructor(e){super("history-navigation",{}),this.data=e}}class p extends Event{constructor(){super("refresh",{})}}class u extends HTMLElement{constructor(){super(...arguments),this.shadow=this.attachShadow({mode:"open"}),this.address=0}set data(e){if(e.address<0)throw new Error("Address should be greater or equal to zero.");this.address=e.address,this.render()}render(){l(d`
      <style>
        .navigator {
          min-height: 24px;
          display: flex;
          flex-wrap: nowrap;
          justify-content: space-between;
          overflow: hidden;
          align-items: center;
        }

        .navigator-item {
          white-space: nowrap;
          overflow: hidden;
        }

        input {
          text-align: center;
        }

        .navigator-button {
          background: transparent;
          overflow: hidden;
          vertical-align: middle;
          border: none;
          padding: 0px;
        }
      </style>
      <div class="navigator">
        <div class="navigator-item">
          ${this.createButton("ic_undo_16x16_icon",new h("Backward"))}
          ${this.createButton("ic_redo_16x16_icon",new h("Forward"))}
        </div>
        <div class="navigator-item">
          ${this.createButton("ic_page_prev_16x16_icon",new c("Backward"))}
          <input data-input="true" contenteditable="true" value="0x${i(this.address,8)}"/>
          ${this.createButton("ic_page_next_16x16_icon",new c("Forward"))}
        </div>
        ${this.createButton("refresh_12x12_icon",new p)}
      </div>
      `,this.shadow,{eventContext:this})}createButton(e,t){return d`
      <button class="navigator-button" data-button=${t.type} @click=${this.dispatchEvent.bind(this,t)}>
        <devtools-icon .data=${{iconName:e,color:"rgb(110 110 110)",width:"16px"}}>
        </devtools-icon>
      </button>`}}customElements.define("devtools-linear-memory-inspector-navigator",u);var m=Object.freeze({__proto__:null,PageNavigationEvent:c,HistoryNavigationEvent:h,RefreshEvent:p,LinearMemoryNavigator:u});var g,y,v;function f(e,t){switch(e){case g.Int8:case g.Int16:case g.Int32:case g.Int64:return t===v.Decimal||t===v.Hexadecimal||t===v.Octal;case g.Float32:case g.Float64:return t===v.Scientific||t===v.Decimal;case g.Boolean:case g.String:return t===v.None}}function w(e){switch(e){case g.Int8:case g.Int16:case g.Int32:case g.Int64:return!0;default:return!1}}function b(e){switch(e){case g.Int8:case g.Int16:case g.Int32:case g.Int64:case g.Float32:case g.Float64:return!0;default:return!1}}function x(e){const t=new DataView(e.buffer),s=e.endianness===y.Little;let r;switch(e.type){case g.Int8:return r=e.signed?t.getInt8(0):t.getUint8(0),E(r,e.mode);case g.Int16:return r=e.signed?t.getInt16(0,s):t.getUint16(0,s),E(r,e.mode);case g.Int32:return r=e.signed?t.getInt32(0,s):t.getUint32(0,s),E(r,e.mode);case g.Int64:return r=e.signed?t.getBigInt64(0,s):t.getBigUint64(0,s),E(r,e.mode);case g.Float32:return r=t.getFloat32(0,s),T(r,e.mode);case g.Float64:return r=t.getFloat64(0,s),T(r,e.mode);case g.Boolean:return _(t.getInt8(0));case g.String:throw new Error(`Type ${e.type} is not yet implemented`)}}function _(e){return""+!!(1&e)}function T(e,t){switch(t){case v.Decimal:return e.toFixed(2).toString();case v.Scientific:return e.toExponential(2).toString();default:throw new Error(`Unknown mode for floats: ${t}.`)}}function E(e,t){switch(t){case v.Decimal:return e.toString();case v.Hexadecimal:return e.toString(16);case v.Octal:return e.toString(8);default:throw new Error(`Unknown mode for integers: ${t}.`)}}!function(e){e.Int8="Integer 8-bit",e.Int16="Integer 16-bit",e.Int32="Integer 32-bit",e.Int64="Integer 64-bit",e.Float32="Float 32-bit",e.Float64="Float 64-bit",e.Boolean="Boolean",e.String="String"}(g||(g={})),function(e){e.Little="Little Endian",e.Big="Big Endian"}(y||(y={})),function(e){e.Decimal="dec",e.Hexadecimal="hex",e.Octal="oct",e.Scientific="sci",e.None="none"}(v||(v={}));var I=Object.freeze({__proto__:null,VALUE_INTEPRETER_MAX_NUM_BYTES:8,get ValueType(){return g},get Endianness(){return y},get ValueTypeMode(){return v},isValidMode:f,typeHasSignedNotation:w,isNumber:b,format:x,formatBoolean:_,formatFloat:T,formatInteger:E});const R=s,{render:$,html:B}=e,O=new Map([[g.Int8,v.Decimal],[g.Int16,v.Decimal],[g.Int32,v.Decimal],[g.Int64,v.Decimal],[g.Float32,v.Decimal],[g.Float64,v.Decimal],[g.Boolean,v.None],[g.String,v.None]]),S=Array.from(O.keys());class M extends HTMLElement{constructor(){super(...arguments),this.shadow=this.attachShadow({mode:"open"}),this.endianness=y.Little,this.buffer=new ArrayBuffer(0),this.valueTypes=new Set,this.valueTypeModeConfig=O}set data(e){this.buffer=e.buffer,this.valueTypes=e.valueTypes,this.valueTypeModeConfig=O,e.valueTypeModes&&e.valueTypeModes.forEach(((e,t)=>{f(t,e)&&this.valueTypeModeConfig.set(t,e)})),this.render()}render(){$(B`
      <style>
        :host {
          flex: auto;
          display: flex;
        }

        .mode-type {
          color: var(--text-highlight-color);
        }

        .value-types {
          display: grid;
          grid-template-columns: auto auto 1fr 1fr;
          grid-column-gap: 24px;
          grid-row-gap: 4px;
          overflow: hidden;
          padding-left: 12px;
          padding-right: 12px;
        }

        .value-type-cell {
          height: 21px;
          text-overflow: ellipsis;
          white-space: nowrap;
          overflow: hidden;
          display: flex;
        }

        .value-type-cell-no-sign {
          grid-column: 3 / 5;
        }

        .value-type-cell-no-mode {
          grid-column: grid-column: 1 / 3;
        }

      </style>
        <div class="value-types">
          ${S.map((e=>this.valueTypes.has(e)?this.showValue(e):""))}
        </div>
      </div>
    `,this.shadow,{eventContext:this})}showValue(e){return B`
      ${b(e)?B`
          <span class="value-type-cell">${R`${e}`}</span>
          <span class="mode-type value-type-cell">${R`${this.valueTypeModeConfig.get(e)}`}</span>`:B`
          <span class="value-type-cell-no-mode value-type-cell">${R`${e}`}</span>`}

        ${w(e)?B`
          <span class="value-type-cell" data-value="true">+ ${this.parse({type:e,signed:!1})}</span>
          <span class="value-type-cell" data-value="true">± ${this.parse({type:e,signed:!0})}</span>`:B`
          <span class="value-type-cell-no-sign value-type-cell" data-value="true">${this.parse({type:e})}</span>`}
    `}parse(e){const t=this.valueTypeModeConfig.get(e.type);if(!t)throw new Error("No known way of showing value for "+e.type);return x({buffer:this.buffer,type:e.type,endianness:this.endianness,signed:e.signed||!1,mode:t})}}customElements.define("devtools-linear-memory-inspector-interpreter-display",M);var P=Object.freeze({__proto__:null,ValueInterpreterDisplay:M});const z=s,{render:C,html:V}=e;var F;!function(e){e.Integer="Integer",e.Float="Floating point",e.Other="Other"}(F||(F={}));const k=new Map([[F.Integer,[g.Int8,g.Int16,g.Int32,g.Int64]],[F.Float,[g.Float32,g.Float64]],[F.Other,[g.Boolean,g.String]]]);class L extends Event{constructor(e,t){super("type-toggle"),this.data={type:e,checked:t}}}class A extends HTMLElement{constructor(){super(...arguments),this.shadow=this.attachShadow({mode:"open"}),this.valueTypes=new Set}set data(e){this.valueTypes=e.valueTypes,this.render()}render(){C(V`
      <style>
        :host {
          flex: auto;
          display: flex;
          min-height: 20px;
        }

        .settings {
          display: flex;
          flex-wrap: wrap;
          margin: 0px 12px 12px 12px;
          column-gap: 45px;
          row-gap: 15px;
        }

        .value-types-selection {
          display: flex;
          flex-direction: column;
        }

        .value-types-selection + value-types-selection {
          margin-left: 45px;
        }

        .group {
          font-weight: bold;
          margin-bottom: 11px;
        }

        .type-label {
          white-space: nowrap;
        }

        .group + .type-label {
          margin-top: 5px;
        }

        .type-label input {
          margin: 0 6px 0 0;
          padding: 0;
        }

        .type-label + .type-label {
          margin-top: 6px;
        }
      </style>
      <div class="settings">
       ${[...k.keys()].map((e=>V`
          <div class="value-types-selection">
            <span class="group">${e}</span>
            ${this.plotTypeSelections(e)}
          </div>
        `))}
      </div>
      `,this.shadow,{eventContext:this})}plotTypeSelections(e){const t=k.get(e);if(!t)throw new Error("Unknown group "+e);return V`
      ${t.map((e=>V`
          <label class="type-label" title=${e}>
            <input data-input="true" type="checkbox" .checked=${this.valueTypes.has(e)} @change=${t=>this.onTypeToggle(e,t)}>
            <span data-title="true">${z`${e}`}</span>
          </label>
     `))}`}onTypeToggle(e,t){const s=t.target;this.dispatchEvent(new L(e,s.checked))}}customElements.define("devtools-linear-memory-inspector-interpreter-settings",A);var U=Object.freeze({__proto__:null,TypeToggleEvent:L,ValueInterpreterSettings:A});const j=s,{render:N,html:H}=e;class D extends HTMLElement{constructor(){super(...arguments),this.shadow=this.attachShadow({mode:"open"}),this.endianness=y.Little,this.buffer=new ArrayBuffer(0),this.valueTypes=new Set,this.valueTypeModeConfig=new Map,this.showSettings=!1}set data(e){this.endianness=e.endianness,this.buffer=e.value,this.valueTypes=e.valueTypes,this.valueTypeModeConfig=e.valueTypeModes||new Map,this.render()}render(){N(H`
      <style>
        :host {
          flex: auto;
          display: flex;
        }

        .value-interpreter {
          border: var(--divider-border, 1px solid #d0d0d0);
          background-color: var(--toolbar-bg-color, #f3f3f3);
          overflow: hidden;
          --text-highlight-color: #80868b;
          width: 400px;
        }

        .settings-toolbar {
          min-height: 26px;
          display: flex;
          flex-wrap: nowrap;
          justify-content: space-between;
          padding-left: 12px;
          padding-right: 12px;
          align-items: center;
        }

        .settings-toolbar-button {
          display: flex;
          justify-content: center;
          width: 30px;
          height: 20px;
        }

        .divider {
          display: block;
          height: 1px;
          margin-bottom: 12px;
          background-color: var(--divider-color,  #d0d0d0);
        }
      </style>
      <div class="value-interpreter">
        <div class="settings-toolbar">
          <div>
            <span>${j`${this.endianness}`}</span>
            <devtools-icon
              .data=${{iconName:"dropdown_7x6_icon",color:"rgb(110 110 110)",width:"7px"}}>
            </devtools-icon>
          </div>
          <button data-settings="true" class="settings-toolbar-button" title="Toggle value type settings" @click=${this.onSettingsToggled}>
            <devtools-icon
              .data=${{iconName:"settings_14x14_icon",color:"rgb(110 110 110)",width:"14px"}}>
            </devtools-icon>
          </button>
        </div>
        <span class="divider"></span>
        <div>
          ${this.showSettings?H`
              <devtools-linear-memory-inspector-interpreter-settings
                .data=${{valueTypes:this.valueTypes}}
                @type-toggle=${this.onTypeToggle}>
              </devtools-linear-memory-inspector-interpreter-settings>`:H`
              <devtools-linear-memory-inspector-interpreter-display
                .data=${{buffer:this.buffer,valueTypes:this.valueTypes,endianness:this.endianness,valueTypeModes:this.valueTypeModeConfig}}>
              </devtools-linear-memory-inspector-interpreter-display>`}
        </div>
      </div>
    `,this.shadow,{eventContext:this})}onSettingsToggled(){this.showSettings=!this.showSettings,this.render()}onTypeToggle(e){this.dispatchEvent(new q(e.data.type,e.data.checked))}}class q extends Event{constructor(e,t){super("value-type-toggle"),this.data={type:e,checked:t}}}customElements.define("devtools-linear-memory-inspector-interpreter",D);var G=Object.freeze({__proto__:null,LinearMemoryValueInterpreter:D,ValueTypeToggleEvent:q});const{render:Y,html:Z}=e;class W extends Event{constructor(e){super("byte-selected"),this.data=e}}class X extends Event{constructor(e){super("resize"),this.data=e}}class J extends HTMLElement{constructor(){super(...arguments),this.shadow=this.attachShadow({mode:"open"}),this.resizeObserver=new ResizeObserver((()=>this.resize())),this.isObservingResize=!1,this.memory=new Uint8Array,this.address=0,this.memoryOffset=0,this.numRows=1,this.numBytesInRow=J.BYTE_GROUP_SIZE}set data(e){if(e.address<e.memoryOffset||e.address>e.memoryOffset+e.memory.length||e.address<0)throw new Error("Address is out of bounds.");if(e.memoryOffset<0)throw new Error("Memory offset has to be greater or equal to zero.");this.memory=e.memory,this.address=e.address,this.memoryOffset=e.memoryOffset,this.update()}disconnectedCallback(){this.isObservingResize=!1,this.resizeObserver.disconnect()}update(){this.updateDimensions(),this.render(),this.engageResizeObserver()}resize(){this.update(),this.dispatchEvent(new X(this.numBytesInRow*this.numRows))}updateDimensions(){if(0===this.clientWidth||0===this.clientHeight||!this.shadowRoot)return this.numBytesInRow=J.BYTE_GROUP_SIZE,void(this.numRows=1);const e=this.shadowRoot.querySelector(".byte-cell"),t=this.shadowRoot.querySelector(".text-cell"),s=this.shadowRoot.querySelector(".divider"),r=this.shadowRoot.querySelector(".row");if(!(e&&t&&s&&r))return this.numBytesInRow=J.BYTE_GROUP_SIZE,void(this.numRows=1);const n=e.getBoundingClientRect().width,o=t.getBoundingClientRect().width,i=J.BYTE_GROUP_SIZE*(n+o)+J.BYTE_GROUP_MARGIN,a=s.getBoundingClientRect().width,l=this.clientWidth-(e.getBoundingClientRect().left-this.getBoundingClientRect().left)-a;if(l<i)return this.numBytesInRow=J.BYTE_GROUP_SIZE,void(this.numRows=1);this.numBytesInRow=Math.floor(l/i)*J.BYTE_GROUP_SIZE,this.numRows=Math.floor(this.clientHeight/r.clientHeight)}engageResizeObserver(){this.resizeObserver&&!this.isObservingResize&&(this.resizeObserver.observe(this),this.isObservingResize=!0)}render(){Y(Z`
      <style>
        :host {
          flex: auto;
          display: flex;
          min-height: 20px;
        }

        .view {
          overflow: hidden;
          text-overflow: ellipsis;
          box-sizing: border-box;
          --selected-cell-color: #1a1aa6;
        }

        .row {
          display: flex;
          height: 20px;
        }

        .cell {
          text-align: center;
          border: 1px solid transparent;
          border-radius: 2px;
        }

        .cell.selected {
          border-color: var(--selected-cell-color);
          color: var(--selected-cell-color);
          background-color: #cfe8fc;
        }

        .byte-cell {
          min-width: 21px;
        }

        .byte-group-margin {
          margin-left: ${J.BYTE_GROUP_MARGIN}px;
        }

        .text-cell {
          min-width: 14px;
          color: var(--selected-cell-color);
        }

        .address {
          font-size: 11px;
          color: #9aa0a6;
        }

        .address.selected {
          font-weight: bold;
          color: #333333;
        }

        .divider {
          width: 1px;
          background-color: rgb(204, 204, 204);
          margin: 0px 4px 0px 4px;
        }
      </style>
      <div class="view">
          ${this.renderView()}
      </div>
      `,this.shadow,{eventContext:this})}renderView(){const e=[];for(let t=0;t<this.numRows;++t)e.push(this.renderRow(t));return Z`${e}`}renderRow(e){const{startIndex:s,endIndex:r}={startIndex:e*this.numBytesInRow,endIndex:(e+1)*this.numBytesInRow},n={address:!0,selected:Math.floor((this.address-this.memoryOffset)/this.numBytesInRow)===e};return Z`
    <div class="row">
      <span class="${t.classMap(n)}">${i(s+this.memoryOffset,8)}</span>
      <span class="divider"></span>
      ${this.renderByteValues(s,r)}
      <span class="divider"></span>
      ${this.renderCharacterValues(s,r)}
    </div>
    `}renderByteValues(e,s){const r=[];for(let n=e;n<s;++n){const s={cell:!0,"byte-cell":!0,"byte-group-margin":n!==e&&(n-e)%J.BYTE_GROUP_SIZE==0,selected:n===this.address-this.memoryOffset},o=n<this.memory.length?Z`${i(this.memory[n],2)}`:"";r.push(Z`
        <span class="${t.classMap(s)}" @click=${this.onSelectedByte(n+this.memoryOffset)}>
          ${o}
        </span>`)}return Z`${r}`}renderCharacterValues(e,s){const r=[];for(let n=e;n<s;++n){const e={cell:!0,"text-cell":!0,selected:this.address-this.memoryOffset===n},s=n<this.memory.length?Z`${this.toAscii(this.memory[n])}`:"";r.push(Z`<span class="${t.classMap(e)}">${s}</span>`)}return Z`${r}`}toAscii(e){return e>=20&&e<=127?String.fromCharCode(e):"."}onSelectedByte(e){return()=>{this.dispatchEvent(new W(e))}}}J.BYTE_GROUP_MARGIN=8,J.BYTE_GROUP_SIZE=4,customElements.define("devtools-linear-memory-inspector-viewer",J);var K=Object.freeze({__proto__:null,ByteSelectedEvent:W,ResizeEvent:X,LinearMemoryViewer:J});const{render:Q,html:ee}=e;class te{constructor(e,t){if(this.address=0,e<0)throw new Error("Address should be a greater or equal to zero");this.address=e,this.callback=t}valid(){return!0}reveal(){this.callback(this.address)}}class se extends Event{constructor(e,t,s){super("memory-request"),this.data={start:e,end:t,address:s}}}class re extends HTMLElement{constructor(){super(...arguments),this.shadow=this.attachShadow({mode:"open"}),this.history=new r.SimpleHistoryManager(10),this.memory=new Uint8Array,this.memoryOffset=0,this.address=0,this.numBytesPerPage=4,this.valueTypes=new Set([g.Int8,g.Float32,g.Boolean])}set data(e){if(e.address<e.memoryOffset||e.address>e.memoryOffset+e.memory.length||e.address<0)throw new Error("Address is out of bounds.");if(e.memoryOffset<0)throw new Error("Memory offset has to be greater or equal to zero.");this.memory=e.memory,this.address=e.address,this.memoryOffset=e.memoryOffset,this.render()}render(){const{start:e,end:t}=this.getPageRangeForAddress(this.address,this.numBytesPerPage);Q(ee`
      <style>
        :host {
          flex: auto;
          display: flex;
        }

        .view {
          width: 100%;
          display: flex;
          flex: 1;
          flex-direction: column;
          font-family: monospace;
          padding: 9px 12px 9px 7px;
        }

        devtools-linear-memory-inspector-navigator + devtools-linear-memory-inspector-viewer {
          margin-top: 12px;
        }

        .value-interpreter {
          display: flex;
        }
      </style>
      <div class="view">
        <devtools-linear-memory-inspector-navigator
          .data=${{address:this.address}}
          @page-navigation=${this.navigatePage}
          @history-navigation=${this.navigateHistory}></devtools-linear-memory-inspector-navigator>
        <devtools-linear-memory-inspector-viewer
          .data=${{memory:this.memory.slice(e-this.memoryOffset,t-this.memoryOffset),address:this.address,memoryOffset:e}}
          @byte-selected=${e=>this.jumpToAddress(e.data)}
          @resize=${this.resize}>
        </devtools-linear-memory-inspector-viewer>
      </div>
      <div class="value-interpreter">
        <devtools-linear-memory-inspector-interpreter
          .data=${{value:this.memory.slice(this.address-this.memoryOffset,this.address+8).buffer,valueTypes:this.valueTypes,endianness:y.Little}}
          @value-type-toggle=${this.onValueTypeToggled}>
        </devtools-linear-memory-inspector-interpreter/>
      </div>
      `,this.shadow,{eventContext:this})}onValueTypeToggled(e){const{type:t,checked:s}=e.data;s?this.valueTypes.add(t):this.valueTypes.delete(t),this.render()}navigateHistory(e){return"Forward"===e.data?this.history.rollover():this.history.rollback()}navigatePage(e){const t="Forward"===e.data?this.address+this.numBytesPerPage:Math.max(this.address-this.numBytesPerPage,0);this.jumpToAddress(t)}jumpToAddress(e){const t=new te(e,(e=>this.jumpToAddress(e)));this.history.push(t),this.address=e,this.update()}getPageRangeForAddress(e,t){const s=Math.floor(e/t)*t;return{start:s,end:s+t}}resize(e){this.numBytesPerPage=e.data,this.update()}update(){const{start:e,end:t}=this.getPageRangeForAddress(this.address,this.numBytesPerPage);e<this.memoryOffset||t>this.memoryOffset+this.memory.length?this.dispatchEvent(new se(e,t,this.address)):this.render()}}customElements.define("devtools-linear-memory-inspector-inspector",re);var ne=Object.freeze({__proto__:null,MemoryRequestEvent:se,LinearMemoryInspector:re});let oe;HTMLElement;class ie extends n.VBox{constructor(){super(),this.view=ae.instance()}wasShown(){this.view.show(this.contentElement)}}class ae extends n.VBox{constructor(){super(!1);const e=document.createElement("div");e.textContent=ls`No open inspections`,e.style.display="flex",this._tabbedPane=new o.TabbedPane,this._tabbedPane.setPlaceholderElement(e),this._tabbedPane.setCloseableTabs(!0),this._tabbedPane.setAllowTabReorder(!0,!0),this._tabbedPane.addEventListener(o.Events.TabClosed,this._tabClosed,this),this._tabbedPane.show(this.contentElement),this._tabIdToInspectorView=new Map}static instance(){return oe||(oe=new ae),oe}showLinearMemory(e,t,s,r){if(this._tabIdToInspectorView.has(e))return void this._tabbedPane.selectTab(e);const n=new le(s,r);this._tabIdToInspectorView.set(e,n),this._tabbedPane.appendTab(e,t,n,void 0,!1,!0),this._tabbedPane.selectTab(e)}_tabClosed(e){const t=e.data.tabId;this._tabIdToInspectorView.delete(t)}}class le extends n.VBox{constructor(e,t){if(super(!1),t<0||t>e.length())throw new Error("Invalid address to show");this.memoryWrapper=e,this._inspector=document.createElement("devtools-linear-memory-inspector-inspector"),this._inspector.addEventListener("memoryRequest",(e=>{this._memoryRequested(e)})),this.contentElement.appendChild(this._inspector);const s=Math.max(0,t-500),r=s+1e3;this.memoryWrapper.getRange(s,r).then((e=>{this._inspector.data={memory:e,address:t,memoryOffset:s}}))}_memoryRequested(e){const{start:t,end:s,address:r}=e.data;if(r<t||r>=s)throw new Error("Requested address is out of bounds.");if(t<0||t>s||t>=this.memoryWrapper.length())throw new Error("Requested range is out of bounds.");const n=Math.max(s,t+1e3);this.memoryWrapper.getRange(t,n).then((e=>{this._inspector.data={memory:e,address:r,memoryOffset:t}}))}}var de=Object.freeze({__proto__:null,Wrapper:ie,LinearMemoryInspectorPaneImpl:ae,LazyUint8Array:class{getRange(e,t){return Promise.resolve(new Uint8Array([]))}length(){return 0}}});export{ne as LinearMemoryInspector,de as LinearMemoryInspectorPane,a as LinearMemoryInspectorUtils,m as LinearMemoryNavigator,G as LinearMemoryValueInterpreter,K as LinearMemoryViewer,P as ValueInterpreterDisplay,I as ValueInterpreterDisplayUtils,U as ValueInterpreterSettings};
