@walkhi/code-relax 0.1.0-beta.1

package/dist/web/p2p-probe.js

@@ -0,0 +1,83 @@
+(function (root) {
+  // Runs only a bounded connectivity probe. Business frames stay on native WSS.
+  root.CodeRelaxP2pProbe = class {
+    constructor(send, report) {
+      this.send = send; this.report = report; this.closed = false; this.queue = Promise.resolve();
+      this.diagnostics = new root.CodeRelaxP2pDiagnostics();
+    }
+    start() {
+      if (typeof root.RTCPeerConnection !== 'function' || !root.crypto?.getRandomValues) {
+        this.close('unsupported'); return;
+      }
+      this.id = Array.from(crypto.getRandomValues(new Uint8Array(16)), n => n.toString(16).padStart(2, '0')).join('');
+      this.nonce = this.id;
+      this.timer = setTimeout(() => this.close('timeout'), 15000);
+      this.report('negotiating'); this.signal({ kind: 'start' });
+    }
+    createPeer(iceServers) {
+      const peer = this.peer = new RTCPeerConnection({ iceServers });
+      peer.onicecandidate = event => {
+        if (event.candidate && !this.closed) this.signal({ kind: 'candidate', candidate: event.candidate.candidate, mid: event.candidate.sdpMid || '0' });
+        if (event.candidate && !this.closed) this.diagnostics.candidate('local', event.candidate.candidate);
+      };
+      peer.oniceconnectionstatechange = () => { if (!this.closed) this.diagnostics.ice = peer.iceConnectionState; };
+      peer.onicegatheringstatechange = () => { if (!this.closed) this.diagnostics.gathering = peer.iceGatheringState; };
+      peer.onicecandidateerror = () => { if (!this.closed) this.diagnostics.error = 'stun'; };
+      peer.onconnectionstatechange = () => {
+        if (['failed', 'closed', 'disconnected'].includes(peer.connectionState)) this.close('failed');
+      };
+      peer.ondatachannel = event => {
+        if (this.channel || event.channel.label !== 'code-relax-probe-v1') { event.channel.close(); this.close('failed'); return; }
+        const channel = this.channel = event.channel;
+        channel.onopen = () => { if (!this.closed) { this.diagnostics.open = true; channel.send(JSON.stringify({ type: 'ping', nonce: this.nonce })); } };
+        channel.onerror = () => { this.diagnostics.error = 'channel'; this.close('failed'); };
+        channel.onclose = () => this.close('closed');
+        let received = 0;
+        channel.onmessage = event => {
+          if (this.closed) return;
+          try {
+            if (typeof event.data !== 'string' || event.data.length > 4096 || ++received > 4) throw new Error();
+            const message = JSON.parse(event.data);
+            if (message.type === 'ping' && /^[\w-]{16,128}$/.test(message.nonce)) {
+              channel.send(JSON.stringify({ type: 'pong', nonce: message.nonce })); this.pingReceived = true; this.diagnostics.ping = true;
+            } else if (message.type === 'pong' && message.nonce === this.nonce) { this.pongReceived = true; this.diagnostics.pong = true; }
+            else throw new Error();
+            if (this.pingReceived && this.pongReceived) {
+              this.report('verified', this.diagnostics.snapshot('verified')); clearTimeout(this.timer);
+              // Allow the remote peer to receive the final pong before closing.
+              this.timer = setTimeout(() => this.close('complete'), 1000);
+            }
+          } catch { this.diagnostics.error = 'frame'; this.close('failed'); }
+        };
+      };
+    }
+    signal(value) { this.send({ type: 'p2p-probe', version: 1, probeId: this.id, ...value }); }
+    receive(message) {
+      if (this.closed || message.probeId !== this.id || message.version !== 1) return;
+      this.queue = this.queue.then(async () => {
+        if (this.closed) return;
+        if (message.kind === 'offer' && !this.offerReceived) {
+          this.offerReceived = true;
+          this.createPeer((message.iceServers || []).map(url => ({ urls: url })));
+          await this.peer.setRemoteDescription({ type: 'offer', sdp: message.sdp });
+          this.diagnostics.offer = true;
+          const answer = await this.peer.createAnswer();
+          if (this.closed) return;
+          await this.peer.setLocalDescription(answer);
+          this.diagnostics.answer = true;
+          if (!this.closed) this.signal({ kind: 'answer', sdp: answer.sdp });
+        } else if (message.kind === 'candidate') {
+          this.diagnostics.candidate('remote', message.candidate);
+          await this.peer.addIceCandidate({ candidate: message.candidate, sdpMid: message.mid });
+        } else this.close('failed');
+      }).catch(() => { this.diagnostics.error = message.kind === 'candidate' ? 'candidate' : 'description'; this.close('failed'); });
+    }
+    close(state = 'closed') {
+      if (this.closed) return;
+      this.closed = true; clearTimeout(this.timer);
+      this.channel?.close(); this.peer?.close();
+      if (this.id) this.signal({ kind: 'close' });
+      if (!(this.pingReceived && this.pongReceived)) this.report(state, this.diagnostics.snapshot(state));
+    }
+  };
+})(globalThis);

package/dist/web/resources.json

@@ -0,0 +1 @@
+["server-requests.js","approval-ui.js","chat.css","highlight.min.js","highlight-powershell.min.js","capabilities.js","timeline-sync.js","harmony-platform.js","client-platform.js","lan-session.js","history-cache.js","p2p-diagnostics.js","p2p-probe.js","self-relay-session.js","chat-transport.js","chat.js"]

package/dist/web/self-relay-session.js

@@ -0,0 +1,119 @@
+(function (root) {
+  let socketSerial = 0;
+  const nativeViews = new Map();
+  root.computerConnectionEvent = (key, event, value) => nativeViews.get(key)?.emit(event, JSON.parse(value));
+  class NativeView extends EventTarget {
+    constructor() {
+      super(); this.key = `${Date.now()}-${++socketSerial}`; this.readyState = 0; nativeViews.set(this.key, this);
+      queueMicrotask(() => { if (this.readyState === 0) { this.readyState = 1; this.emit('open', {}); } });
+    }
+    emit(type, value) {
+      if (this.readyState === 3) return;
+      if (type === 'message' && value.type === 'p2p-probe') { this.probe?.receive(value); return; }
+      if (type === 'message' && value.type === 'p2p-restart') { this.startProbe(); return; }
+      if (type === 'close') this.probe?.close();
+      if (type === 'close') { this.readyState = 3; nativeViews.delete(this.key); }
+      const event = type === 'message' ? new MessageEvent(type, { data: JSON.stringify(value) }) : new Event(type);
+      if (type === 'close') Object.defineProperty(event, 'code', { value: value.code });
+      this.dispatchEvent(event); this[`on${type}`]?.(event);
+    }
+    // WebRTC is diagnostic-only. Never start it on connection readiness; the
+    // native diagnostics dialog explicitly emits p2p-restart for one test.
+    startProbe() {
+      this.probe?.close('replaced');
+      this.probe = new root.CodeRelaxP2pProbe(
+        signal => root.codexNative.computerTransport(JSON.stringify({ type: 'p2p-probe', key: this.key, payload: JSON.stringify(signal) })),
+        (state, diagnostic) => {
+          if (diagnostic) root.codexNative.computerTransport(JSON.stringify({ type: 'p2p-diagnostic', key: this.key, payload: diagnostic }));
+          root.codexNative.computerTransport(JSON.stringify({ type: 'p2p-status', key: this.key, payload: state }));
+        });
+      try { this.probe.start(); }
+      catch { this.probe.diagnostics.error = 'initialization'; this.probe.close('failed'); }
+    }
+    send(value) {
+      const frame = JSON.parse(value);
+      if (frame.type === 'data') root.codexNative.computerTransport(JSON.stringify({ type: 'send', key: this.key, payload: frame.payload }));
+      else root.codexNative.computerTransport(JSON.stringify({ type: 'attach', key: this.key }));
+    }
+    close() {
+      this.probe?.close();
+      root.codexNative.computerTransport(JSON.stringify({ type: 'detach', key: this.key }));
+      this.emit('close', { code: 1000 });
+    }
+  }
+  // Reuse LAN request, subscription and disconnect semantics; replace only the envelope.
+  root.CodexSelfRelaySession = class extends root.CodexLanSession {
+    constructor() { super(''); this.config = root.codexSelfRelayConfig; }
+    createSocket() { return root.codexNative?.computerTransport ? new NativeView() : super.createSocket(); }
+    connect() { return this.terminalError ? Promise.reject(this.terminalError) : super.connect(); }
+    socketUrl() {
+      const url = new URL(this.config.url);
+      if ((url.protocol !== 'wss:' && !(url.protocol === 'ws:' && url.hostname === '127.0.0.1')) ||
+          url.pathname !== '/relay' || url.search || url.hash || url.username || url.password) throw new Error('无效的Code Relax 中继地址');
+      return url.href;
+    }
+    authenticationMessage() {
+      const { room, code, credential, clientId } = this.config;
+      return code ? { type: 'pair', room, code, clientId, ...(credential ? { credential } : {}) } : { type: 'resume', room, credential, clientId };
+    }
+    closeError(event) {
+      const reasons = { 4401: '设备授权不存在或已撤销，请重新扫码授权', 4408: '配对码已过期或使用，请生成新的首次授权码',
+        4406: 'Code Relax 中继协议需要升级，请更新工作站和手机', 4409: '连接已由同一设备的新连接接替', 4410: '工作站暂时离线，正在等待恢复，设备授权仍保留',
+        1011: '工作站 Bridge 暂时不可用，正在恢复连接' };
+      const error = new TypeError(reasons[event.code] || `Code Relax 中继连接已断开（${event.code}），正在恢复`);
+      error.code = event.code;
+      if (event.code === 4401) root.codexHistoryCache?.clear().catch(() => {});
+      if ([1008, 4401, 4406, 4408, 4409, 4429].includes(event.code)) this.terminalError = error;
+      return error;
+    }
+    encodeMessage(message) {
+      const frame = { type: 'data', payload: JSON.stringify(message) };
+      if (new TextEncoder().encode(JSON.stringify(frame)).length > 8 * 1024 * 1024) throw new Error('Code Relax 中继私测消息超过 8 MiB，请减少图片或内容');
+      return frame;
+    }
+    async pause() {
+      const socket = this.socket;
+      if (!socket || socket.readyState === 3) return super.pause();
+      const closed = new Promise(resolve => socket.addEventListener('close', resolve, { once: true }));
+      await super.pause(); await closed;
+    }
+    decodeMessage(message) {
+      if (message.type === 'paired') {
+        if (message.room !== this.config.room) throw new Error('配对工作站不匹配');
+        if (this.config.clientId && message.protocolVersion !== 3) {
+          this.terminalError = Object.assign(new TypeError('Code Relax 中继协议需要升级'), { code: 4406 }); throw this.terminalError;
+        }
+        if (message.credential && this.config.credential && message.credential !== this.config.credential) throw new Error('设备凭据与已保存身份不一致');
+        if (message.credential) this.config.credential = message.credential;
+        if (Number.isSafeInteger(message.revision) && message.revision >= 0) {
+          if (this.config.revision !== undefined && this.config.revision !== message.revision) root.codexHistoryCache?.clear().catch(() => {});
+          this.config.revision = message.revision;
+        }
+        delete this.config.code;
+        root.codexNative?.selfRelayPaired?.(message.room, this.config.credential, this.config.revision || 0);
+        return null;
+      }
+      if (message.type === 'lan-candidates' && Array.isArray(message.candidates)) {
+        root.codexNative?.selfRelayLanCandidates?.(JSON.stringify(message.candidates));
+        return null;
+      }
+      if (message.type === 'computer-info' && typeof message.hostName === 'string') {
+        root.codexNative?.selfRelayComputerInfo?.(message.hostName);
+        return null;
+      }
+      if (message.type === 'ready') return message;
+      if (message.type === 'data' && typeof message.payload === 'string') {
+        const started = performance.now();
+        const decoded = JSON.parse(message.payload);
+        const path = this.pending.get(decoded.id)?.path || '';
+        const route = /\/timeline(?:\?|$)/.test(path) ? 'timeline' : /\/history\?/.test(path) ? 'history'
+          : /^\/api\/threads\?/.test(path) ? 'list' : '';
+        if (route && root.codexNative?.reportSyncMetric) {
+          root.codexNative.reportSyncMetric(`stage=parse;route=${route};ms=${Math.round(performance.now() - started)};chars=${message.payload.length}`);
+        }
+        return decoded;
+      }
+      throw new Error('无效的Code Relax 中继消息');
+    }
+  };
+})(globalThis);

package/dist/web/server-requests.js

@@ -0,0 +1,67 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexServerRequests = factory();
+})(globalThis, function () {
+  const command = 'item/commandExecution/requestApproval';
+  const file = 'item/fileChange/requestApproval';
+  const input = 'item/tool/requestUserInput';
+  const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+  function decisions(request) {
+    if (request.method === command) return request.params.availableDecisions ?? ['accept', 'acceptForSession', 'decline', 'cancel'];
+    if (request.method === file) return ['accept', 'acceptForSession', 'decline', 'cancel'];
+    return [];
+  }
+  function validate(request, result) {
+    if ([command, file].includes(request.method)) {
+      if (!result || Object.keys(result).length !== 1 || !decisions(request).some(value => equal(value, result.decision))) throw new Error('审批选项不属于当前请求');
+      return;
+    }
+    if (request.method === input) {
+      const questions = request.params.questions || [];
+      if (!result?.answers || Object.keys(result).length !== 1 || Object.keys(result.answers).length !== questions.length
+        || questions.some(q => !Array.isArray(result.answers[q.id]?.answers) || result.answers[q.id].answers.some(a => typeof a !== 'string'))) throw new Error('回答格式无效');
+      return;
+    }
+    throw new Error('此类请求需在工作站处理');
+  }
+  class Store {
+    constructor(epoch, changed = () => {}) { this.epoch = epoch; this.changed = changed; this.requests = new Map(); }
+    list(threadId) { return [...this.requests.values()].filter(r => r.params.threadId === threadId).map(r => ({ ...r })); }
+    receive(message) {
+      if (!['string', 'number'].includes(typeof message.id) || !message.params?.threadId || this.requests.has(message.id)) return;
+      const request = { id: message.id, method: message.method, params: message.params, epoch: this.epoch, status: 'pending' };
+      this.requests.set(message.id, request); this.changed(request.params.threadId);
+    }
+    notification(method, params) {
+      if (method === 'serverRequest/resolved') {
+        const request = this.requests.get(params.requestId);
+        if (request?.params.threadId === params.threadId) { this.requests.delete(params.requestId); this.changed(params.threadId); }
+      } else if (method === 'turn/completed' || method === 'thread/closed') {
+        for (const [id, r] of this.requests) if (r.params.threadId === params.threadId && (method === 'thread/closed' || r.params.turnId === params.turn?.id)) this.requests.delete(id);
+        this.changed(params.threadId);
+      }
+    }
+    forget(threadId) {
+      for (const [id, request] of this.requests) if (request.params.threadId === threadId) this.requests.delete(id);
+      this.changed(threadId);
+    }
+    reset(epoch) {
+      const threads = new Set([...this.requests.values()].map(r => r.params.threadId));
+      this.requests.clear(); this.epoch = epoch; for (const id of threads) this.changed(id);
+    }
+    async respond(threadId, { id, epoch, result }, send) {
+      const request = this.requests.get(id);
+      if (!request || epoch !== this.epoch || request.params.threadId !== threadId) throw new Error('审批已处理或连接已变化，请等待同步');
+      if (request.status !== 'pending') throw new Error('决定已提交，正在等待工作站确认，请勿重复提交');
+      validate(request, result);
+      request.status = 'submitted'; this.changed(threadId);
+      try { await send({ id: request.id, result }); }
+      catch (error) {
+        if (this.requests.get(id) === request) { request.status = 'unknown'; this.changed(threadId); }
+        throw new Error('审批发送结果未确认，请检查工作站；不会自动重发。' + error.message);
+      }
+      return { submitted: true };
+    }
+  }
+  return { Store, decisions, validate, command, file, input };
+});

package/dist/web/timeline-sync.js

@@ -0,0 +1,67 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexTimelineSync = factory();
+})(globalThis, function () {
+  const equal = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+  function changedFields(previous, current, ignored) {
+    const set = {}, append = {}, unset = [];
+    for (const key of new Set([...Object.keys(previous || {}), ...Object.keys(current || {})])) {
+      if (ignored.has(key) || equal(previous?.[key], current?.[key])) continue;
+      if (!Object.hasOwn(current, key)) { unset.push(key); continue; }
+      const before = previous?.[key], after = current[key];
+      if (typeof before === 'string' && typeof after === 'string' && after.startsWith(before)) append[key] = after.slice(before.length);
+      else set[key] = after;
+    }
+    return { set, append, unset };
+  }
+  const nonempty = changes => Object.keys(changes.set).length || Object.keys(changes.append).length || changes.unset.length;
+  function diffTurn(previous, current) {
+    if (!previous || !current || previous.id !== current.id) return null;
+    const before = Array.isArray(previous.entries) ? previous.entries : [];
+    const after = Array.isArray(current.entries) ? current.entries : [];
+    if (after.length < before.length) return null;
+    const entries = [];
+    for (let index = 0; index < before.length; index++) {
+      if (before[index]?.id !== after[index]?.id || before[index]?.type !== after[index]?.type ||
+          before[index]?.role !== after[index]?.role || before[index]?.kind !== after[index]?.kind) return null;
+      const changes = changedFields(before[index], after[index], new Set(['id', 'type', 'role', 'kind']));
+      if (nonempty(changes)) entries.push({ id: after[index].id, index, ...changes });
+    }
+    const turn = changedFields(previous, current, new Set(['id', 'entries']));
+    const appended = after.slice(before.length);
+    return { id: current.id, ...turn, entries, appended };
+  }
+  function applyChanges(target, changes) {
+    const result = { ...target, ...(changes.set || {}) };
+    for (const key of changes.unset || []) delete result[key];
+    for (const [key, suffix] of Object.entries(changes.append || {})) {
+      if (typeof result[key] !== 'string' || typeof suffix !== 'string') throw new Error('增量字段类型不匹配');
+      result[key] += suffix;
+    }
+    return result;
+  }
+  function applyTurnPatch(turn, patch) {
+    if (!turn || turn.id !== patch?.id) throw new Error('增量轮次不存在');
+    const next = applyChanges(turn, patch), entries = (turn.entries || []).map(entry => ({ ...entry }));
+    for (const entryPatch of patch.entries || []) {
+      const entry = entries[entryPatch.index];
+      if (!entry || entry.id !== entryPatch.id) throw new Error('增量条目边界不匹配');
+      entries[entryPatch.index] = applyChanges(entry, entryPatch);
+    }
+    for (const entry of patch.appended || []) {
+      if (entries.some(existing => existing.id === entry.id)) throw new Error('增量条目重复');
+      entries.push(entry);
+    }
+    next.entries = entries; return next;
+  }
+  function acceptSyncUpdate(current, incoming) {
+    if (incoming.reset) return { reset: true, next: incoming };
+    const valid = current && incoming.id === current.id && incoming.epoch === current.epoch &&
+      Number.isSafeInteger(incoming.fromSeq) && incoming.fromSeq >= 1 &&
+      Number.isSafeInteger(incoming.toSeq) && incoming.toSeq >= incoming.fromSeq;
+    if (!valid || incoming.fromSeq > current.seq + 1) throw new Error('实时更新序号不连续');
+    if (incoming.toSeq <= current.seq) return { duplicate: true, next: current };
+    return { next: { ...current, seq: incoming.toSeq } };
+  }
+  return { diffTurn, applyTurnPatch, acceptSyncUpdate };
+});

package/dist/web/vendor/README.md

@@ -0,0 +1,14 @@
+# Vendored browser dependency
+
+- `markdown-it.umd.min.js`: markdown-it 15.0.2 browser UMD build
+- Source: https://github.com/markdown-it/markdown-it
+- License: MIT; see `markdown-it.LICENSE.txt`
+- SHA-256: `635972b985228e8af9f0143647c68616b7a3bb09f6946e7e4a52e43dcf5e7be5`
+- `highlight.min.js`: highlight.js 11.12.0 common browser build
+- `highlight-powershell.min.js`: highlight.js 11.12.0 PowerShell language module
+- Source: https://github.com/highlightjs/highlight.js
+- License: BSD-3-Clause; see `highlight.LICENSE.txt`
+- SHA-256 (`highlight.min.js`): `8ab71eb09c51f501e5e25157d9cff100e46cc29bcbfc744d0b746d451fca7f53`
+- SHA-256 (`highlight-powershell.min.js`): `fc298b3e0db362e531e6d58988b7a78f83da19df6b5d74db75bc961b2bfbfd3d`
+
+These files are served locally by the Bridge. They are not fetched from a CDN at runtime.

package/dist/web/vendor/highlight-powershell.min.js

@@ -0,0 +1,39 @@
+/*! `powershell` grammar compiled for Highlight.js 11.12.0 */
+(()=>{var e=(()=>{"use strict";return e=>{const n={$pattern:/-?[A-z\.\-]+\b/,
+keyword:"if else foreach return do while until elseif begin for trap data dynamicparam end break throw param continue finally in switch exit filter try process catch hidden static parameter",
+built_in:"ac asnp cat cd CFS chdir clc clear clhy cli clp cls clv cnsn compare copy cp cpi cpp curl cvpa dbp del diff dir dnsn ebp echo|0 epal epcsv epsn erase etsn exsn fc fhx fl ft fw gal gbp gc gcb gci gcm gcs gdr gerr ghy gi gin gjb gl gm gmo gp gps gpv group gsn gsnp gsv gtz gu gv gwmi h history icm iex ihy ii ipal ipcsv ipmo ipsn irm ise iwmi iwr kill lp ls man md measure mi mount move mp mv nal ndr ni nmo npssc nsn nv ogv oh popd ps pushd pwd r rbp rcjb rcsn rd rdr ren ri rjb rm rmdir rmo rni rnp rp rsn rsnp rujb rv rvpa rwmi sajb sal saps sasv sbp sc scb select set shcm si sl sleep sls sort sp spjb spps spsv start stz sujb sv swmi tee trcm type wget where wjb write"
+},s={begin:"`[\\s\\S]",relevance:0},i={className:"variable",variants:[{
+begin:/\$\B/},{className:"keyword",begin:/\$this/},{begin:/\$[\w\d][\w\d_:]*/}]
+},a={className:"string",variants:[{begin:/"/,end:/"/},{begin:/@"/,end:/^"@/}],
+contains:[s,i,{className:"variable",begin:/\$[A-z]/,end:/[^A-z]/}]},t={
+className:"string",variants:[{begin:/'/,end:/'/},{begin:/@'/,end:/^'@/}]
+},r=e.inherit(e.COMMENT(null,null),{variants:[{begin:/#/,end:/$/},{begin:/<#/,
+end:/#>/}],contains:[{className:"doctag",variants:[{
+begin:/\.(synopsis|description|example|inputs|outputs|notes|link|component|role|functionality)/
+},{
+begin:/\.(parameter|forwardhelptargetname|forwardhelpcategory|remotehelprunspace|externalhelp)\s+\S+/
+}]}]}),c={className:"class",beginKeywords:"class enum",end:/\s*[{]/,
+excludeEnd:!0,relevance:0,contains:[e.TITLE_MODE]},l={className:"function",
+begin:/function\s+/,end:/\s*\{|$/,excludeEnd:!0,returnBegin:!0,relevance:0,
+contains:[{begin:"function",relevance:0,className:"keyword"},{className:"title",
+begin:/\w[\w\d]*((-)[\w\d]+)*/,relevance:0},{begin:/\(/,end:/\)/,
+className:"params",relevance:0,contains:[i]}]},o={begin:/using\s/,end:/$/,
+returnBegin:!0,contains:[a,t,{className:"keyword",
+begin:/(using|assembly|command|module|namespace|type)/}]},p={
+className:"function",begin:/\[.*\]\s*[\w]+[ ]??\(/,end:/$/,returnBegin:!0,
+relevance:0,contains:[{className:"keyword",
+begin:"(".concat(n.keyword.toString().replace(/\s/g,"|"),")\\b"),endsParent:!0,
+relevance:0},e.inherit(e.TITLE_MODE,{endsParent:!0})]
+},g=[p,r,s,e.NUMBER_MODE,a,t,{className:"built_in",variants:[{
+begin:"(Add|Clear|Close|Copy|Enter|Exit|Find|Format|Get|Hide|Join|Lock|Move|New|Open|Optimize|Pop|Push|Redo|Remove|Rename|Reset|Resize|Search|Select|Set|Show|Skip|Split|Step|Switch|Undo|Unlock|Watch|Backup|Checkpoint|Compare|Compress|Convert|ConvertFrom|ConvertTo|Dismount|Edit|Expand|Export|Group|Import|Initialize|Limit|Merge|Mount|Out|Publish|Restore|Save|Sync|Unpublish|Update|Approve|Assert|Build|Complete|Confirm|Deny|Deploy|Disable|Enable|Install|Invoke|Register|Request|Restart|Resume|Start|Stop|Submit|Suspend|Uninstall|Unregister|Wait|Debug|Measure|Ping|Repair|Resolve|Test|Trace|Connect|Disconnect|Read|Receive|Send|Write|Block|Grant|Protect|Revoke|Unblock|Unprotect|Use|ForEach|Sort|Tee|Where)+(-)[\\w\\d]+"
+}]},i,{className:"literal",begin:/\$(null|true|false)\b/},{
+className:"selector-tag",begin:/@\B/,relevance:0}],m={begin:/\[/,end:/\]/,
+excludeBegin:!0,excludeEnd:!0,relevance:0,contains:[].concat("self",g,{
+begin:"(string|char|byte|int|long|bool|decimal|single|double|DateTime|xml|array|hashtable|void)",
+className:"built_in",relevance:0},{className:"type",begin:/[\.\w\d]+/,
+relevance:0})};return p.contains.unshift(m),{name:"PowerShell",
+aliases:["pwsh","ps","ps1"],case_insensitive:!0,keywords:n,
+contains:g.concat(c,l,o,{variants:[{className:"operator",
+begin:"(-and|-as|-band|-bnot|-bor|-bxor|-casesensitive|-ccontains|-ceq|-cge|-cgt|-cle|-clike|-clt|-cmatch|-cne|-cnotcontains|-cnotlike|-cnotmatch|-contains|-creplace|-csplit|-eq|-exact|-f|-file|-ge|-gt|-icontains|-ieq|-ige|-igt|-ile|-ilike|-ilt|-imatch|-in|-ine|-inotcontains|-inotlike|-inotmatch|-ireplace|-is|-isnot|-isplit|-join|-le|-like|-lt|-match|-ne|-not|-notcontains|-notin|-notlike|-notmatch|-or|-regex|-replace|-shl|-shr|-split|-wildcard|-xor)\\b"
+},{className:"literal",begin:/(-){1,2}[\w\d-]+/,relevance:0}]},m)}}})()
+;hljs.registerLanguage("powershell",e)})();

package/dist/web/vendor/highlight.LICENSE.txt

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2006, Ivan Sagalaev.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.