diff --git a/.README.md.swp b/.README.md.swp new file mode 100644 index 0000000..efa3256 Binary files /dev/null and b/.README.md.swp differ diff --git a/.index.ts.swp b/.index.ts.swp new file mode 100644 index 0000000..4c5e4d3 Binary files /dev/null and b/.index.ts.swp differ diff --git a/.utility.ts.swp b/.utility.ts.swp new file mode 100644 index 0000000..79a928f Binary files /dev/null and b/.utility.ts.swp differ diff --git a/.websocket-handler.ts.swp b/.websocket-handler.ts.swp new file mode 100644 index 0000000..22db59b Binary files /dev/null and b/.websocket-handler.ts.swp differ diff --git a/1.vim b/1.vim new file mode 100644 index 0000000..e7a1da5 --- /dev/null +++ b/1.vim @@ -0,0 +1,1767 @@ +let SessionLoad = 1 +if &cp | set nocp | endif +let s:cpo_save=&cpo +set cpo&vim +inoremap (table-mode-tableize) |:call tablemode#TableizeInsertMode() a +inoremap coc#pum#visible() ? coc#pum#scroll(0) : "\" +inoremap coc#pum#visible() ? coc#pum#scroll(1) : "\" +inoremap coc#pum#visible() ? coc#pum#confirm() : coc#inline#visible() ? coc#inline#accept() :"\" +inoremap coc#pum#visible() ? coc#pum#cancel() : coc#inline#visible() ? coc#inline#cancel() : "\" +inoremap coc#pum#visible() ? coc#pum#prev(0) : coc#inline#visible() ? coc#inline#prev() :"\" +inoremap coc#pum#visible() ? coc#pum#next(0) : coc#inline#visible() ? coc#inline#next() :"\" +inoremap coc#pum#visible() ? coc#pum#prev(1) : coc#inline#visible() ? coc#inline#prev() : "\" +inoremap coc#pum#visible() ? coc#pum#next(1) : coc#inline#visible() ? coc#inline#next() : "\" +nnoremap  :NERDTreeFind +nnoremap  :NERDTree +nmap  (ctrlp) +nnoremap  :NERDTreeToggle +xmap \T (table-mode-tableize-delimiter) +xmap \tt (table-mode-tableize) +nmap \tt (table-mode-tableize) +nnoremap \tm :call tablemode#Toggle() +nnoremap \4 :call SN("4") +nnoremap \3 :call SN("3") +nnoremap \2 :call SN("2") +nnoremap \1 :call SN("1") +nmap \rn (coc-rename) +xmap gx NetrwBrowseXVis +nmap gx NetrwBrowseX +nnoremap GitGutterPreviewHunk :call gitgutter#utility#warn('Please change your map GitGutterPreviewHunk to (GitGutterPreviewHunk)') +nnoremap (GitGutterPreviewHunk) :GitGutterPreviewHunk +nnoremap GitGutterUndoHunk :call gitgutter#utility#warn('Please change your map GitGutterUndoHunk to (GitGutterUndoHunk)') +nnoremap (GitGutterUndoHunk) :GitGutterUndoHunk +nnoremap GitGutterStageHunk :call gitgutter#utility#warn('Please change your map GitGutterStageHunk to (GitGutterStageHunk)') +nnoremap (GitGutterStageHunk) :GitGutterStageHunk +xnoremap GitGutterStageHunk :call gitgutter#utility#warn('Please change your map GitGutterStageHunk to (GitGutterStageHunk)') +xnoremap (GitGutterStageHunk) :GitGutterStageHunk +nnoremap GitGutterPrevHunk &diff ? '[c' : ":\call gitgutter#utility#warn('Please change your map \GitGutterPrevHunk to \(GitGutterPrevHunk)')\ " +nnoremap (GitGutterPrevHunk) &diff ? '[c' : ":\execute v:count1 . 'GitGutterPrevHunk'\ " +nnoremap GitGutterNextHunk &diff ? ']c' : ":\call gitgutter#utility#warn('Please change your map \GitGutterNextHunk to \(GitGutterNextHunk)')\ " +nnoremap (GitGutterNextHunk) &diff ? ']c' : ":\execute v:count1 . 'GitGutterNextHunk'\ " +xnoremap (GitGutterTextObjectOuterVisual) :call gitgutter#hunk#text_object(0) +xnoremap (GitGutterTextObjectInnerVisual) :call gitgutter#hunk#text_object(1) +onoremap (GitGutterTextObjectOuterPending) :call gitgutter#hunk#text_object(0) +onoremap (GitGutterTextObjectInnerPending) :call gitgutter#hunk#text_object(1) +xnoremap NetrwBrowseXVis :call netrw#BrowseXVis() +nnoremap NetrwBrowseX :call netrw#BrowseX(netrw#GX(),netrw#CheckIfRemote(netrw#GX())) +nmap (ctrlp) +nnoremap (ctrlp) :CtrlP +nnoremap (table-mode-sort) :call tablemode#spreadsheet#Sort('') +nnoremap (table-mode-echo-cell) :call tablemode#spreadsheet#EchoCell() +nnoremap (table-mode-eval-formula) :call tablemode#spreadsheet#formula#EvaluateFormulaLine() +nnoremap (table-mode-add-formula) :call tablemode#spreadsheet#formula#Add() +nnoremap (table-mode-insert-column-after) :call tablemode#spreadsheet#InsertColumn(1) +nnoremap (table-mode-insert-column-before) :call tablemode#spreadsheet#InsertColumn(0) +nnoremap (table-mode-delete-column) :call tablemode#spreadsheet#DeleteColumn() +nnoremap (table-mode-delete-row) :call tablemode#spreadsheet#DeleteRow() +xnoremap (table-mode-cell-text-object-i) :call tablemode#spreadsheet#cell#TextObject(1) +xnoremap (table-mode-cell-text-object-a) :call tablemode#spreadsheet#cell#TextObject(0) +onoremap (table-mode-cell-text-object-i) :call tablemode#spreadsheet#cell#TextObject(1) +onoremap (table-mode-cell-text-object-a) :call tablemode#spreadsheet#cell#TextObject(0) +nnoremap (table-mode-motion-right) :call tablemode#spreadsheet#cell#Motion('l') +nnoremap (table-mode-motion-left) :call tablemode#spreadsheet#cell#Motion('h') +nnoremap (table-mode-motion-down) :call tablemode#spreadsheet#cell#Motion('j') +nnoremap (table-mode-motion-up) :call tablemode#spreadsheet#cell#Motion('k') +nnoremap (table-mode-realign) :call tablemode#table#Realign('.') +xnoremap (table-mode-tableize-delimiter) :call tablemode#TableizeByDelimiter() +xnoremap (table-mode-tableize) :Tableize +nnoremap (table-mode-tableize) :Tableize +onoremap (coc-classobj-a) :call CocAction('selectSymbolRange', v:false, '', ['Interface', 'Struct', 'Class']) +onoremap (coc-classobj-i) :call CocAction('selectSymbolRange', v:true, '', ['Interface', 'Struct', 'Class']) +vnoremap (coc-classobj-a) :call CocAction('selectSymbolRange', v:false, visualmode(), ['Interface', 'Struct', 'Class']) +vnoremap (coc-classobj-i) :call CocAction('selectSymbolRange', v:true, visualmode(), ['Interface', 'Struct', 'Class']) +onoremap (coc-funcobj-a) :call CocAction('selectSymbolRange', v:false, '', ['Method', 'Function']) +onoremap (coc-funcobj-i) :call CocAction('selectSymbolRange', v:true, '', ['Method', 'Function']) +vnoremap (coc-funcobj-a) :call CocAction('selectSymbolRange', v:false, visualmode(), ['Method', 'Function']) +vnoremap (coc-funcobj-i) :call CocAction('selectSymbolRange', v:true, visualmode(), ['Method', 'Function']) +nnoremap (coc-cursors-position) :call CocAction('cursorsSelect', bufnr('%'), 'position', 'n') +nnoremap (coc-cursors-word) :call CocAction('cursorsSelect', bufnr('%'), 'word', 'n') +vnoremap (coc-cursors-range) :call CocAction('cursorsSelect', bufnr('%'), 'range', visualmode()) +nnoremap (coc-refactor) :call CocActionAsync('refactor') +nnoremap (coc-command-repeat) :call CocAction('repeatCommand') +nnoremap (coc-float-jump) :call coc#float#jump() +nnoremap (coc-float-hide) :call coc#float#close_all() +nnoremap (coc-fix-current) :call CocActionAsync('doQuickfix') +nnoremap (coc-openlink) :call CocActionAsync('openLink') +nnoremap (coc-references-used) :call CocActionAsync('jumpUsed') +nnoremap (coc-references) :call CocActionAsync('jumpReferences') +nnoremap (coc-type-definition) :call CocActionAsync('jumpTypeDefinition') +nnoremap (coc-implementation) :call CocActionAsync('jumpImplementation') +nnoremap (coc-declaration) :call CocActionAsync('jumpDeclaration') +nnoremap (coc-definition) :call CocActionAsync('jumpDefinition') +nnoremap (coc-diagnostic-prev-error) :call CocActionAsync('diagnosticPrevious', 'error') +nnoremap (coc-diagnostic-next-error) :call CocActionAsync('diagnosticNext', 'error') +nnoremap (coc-diagnostic-prev) :call CocActionAsync('diagnosticPrevious') +nnoremap (coc-diagnostic-next) :call CocActionAsync('diagnosticNext') +nnoremap (coc-diagnostic-info) :call CocActionAsync('diagnosticInfo') +nnoremap (coc-format) :call CocActionAsync('format') +nnoremap (coc-rename) :call CocActionAsync('rename') +nnoremap (coc-codeaction-source) :call CocActionAsync('codeAction', '', ['source'], v:true) +nnoremap (coc-codeaction-refactor) :call CocActionAsync('codeAction', 'cursor', ['refactor'], v:true) +nnoremap (coc-codeaction-cursor) :call CocActionAsync('codeAction', 'cursor') +nnoremap (coc-codeaction-line) :call CocActionAsync('codeAction', 'currline') +nnoremap (coc-codeaction) :call CocActionAsync('codeAction', '') +vnoremap (coc-codeaction-refactor-selected) :call CocActionAsync('codeAction', visualmode(), ['refactor'], v:true) +vnoremap (coc-codeaction-selected) :call CocActionAsync('codeAction', visualmode()) +vnoremap (coc-format-selected) :call CocActionAsync('formatSelected', visualmode()) +nnoremap (coc-codelens-action) :call CocActionAsync('codeLensAction') +nnoremap (coc-range-select) :call CocActionAsync('rangeSelect', '', v:true) +vnoremap (coc-range-select-backward) :call CocActionAsync('rangeSelect', visualmode(), v:false) +vnoremap (coc-range-select) :call CocActionAsync('rangeSelect', visualmode(), v:true) +nnoremap :NERDTreeFind +nnoremap :NERDTreeToggle +nnoremap :NERDTree +inoremap  coc#pum#visible() ? coc#pum#cancel() : coc#inline#visible() ? coc#inline#cancel() : "\" +inoremap  coc#pum#visible() ? coc#pum#confirm() : "\ " +inoremap  coc#pum#visible() ? coc#pum#next(1) : coc#inline#visible() ? coc#inline#next() : "\" +inoremap  coc#pum#visible() ? coc#pum#prev(1) : coc#inline#visible() ? coc#inline#prev() : "\" +inoremap  coc#pum#visible() ? coc#pum#confirm() : coc#inline#visible() ? coc#inline#accept() :"\" +let &cpo=s:cpo_save +unlet s:cpo_save +set autoread +set background=dark +set backspace=indent,eol,start +set encoding=utf-8 +set fileencodings=ucs-bom,utf-8,default,latin1 +set nomodeline +set mouse=a +set printoptions=paper:a4 +set ruler +set runtimepath=~/.vim,~/.vim/pack/airblade/start/vim-gitgutter,~/.vim/plugged/coc.nvim,~/.vim/plugged/emmet-vim,~/.vim/plugged/nerdtree,~/.vim/plugged/typescript-vim,~/.vim/plugged/vim-jsx-typescript,~/.vim/plugged/vim-table-mode,~/.vim/plugged/ctrlp.vim,/var/lib/vim/addons,/etc/vim,/usr/share/vim/vimfiles,/usr/share/vim/vim90,/usr/share/vim/vimfiles/after,/etc/vim/after,/var/lib/vim/addons/after,~/.vim/plugged/vim-jsx-typescript/after,~/.vim/after +set shiftwidth=4 +set smarttab +set suffixes=.bak,~,.swp,.o,.info,.aux,.log,.dvi,.bbl,.blg,.brf,.cb,.ind,.idx,.ilg,.inx,.out,.toc +set updatetime=500 +let s:so_save = &g:so | let s:siso_save = &g:siso | setg so=0 siso=0 | setl so=-1 siso=-1 +let v:this_session=expand(":p") +silent only +silent tabonly +cd ~/storage/VDMDI/UDN +if expand('%') == '' && !&modified && line('$') <= 1 && getline(1) == '' + let s:wipebuf = bufnr('%') +endif +if &shortmess =~ 'A' + set shortmess=aoOA +else + set shortmess=aoO +endif +badd +6 package.json +badd +0 README.md +badd +14 static/src/index.tsx +badd +0 static/src/translations.tsx +badd +0 utility.ts +argglobal +%argdel +set stal=2 +tabnew +setlocal\ bufhidden=wipe +tabnew +setlocal\ bufhidden=wipe +tabrewind +edit package.json +let s:save_splitbelow = &splitbelow +let s:save_splitright = &splitright +set splitbelow splitright +wincmd _ | wincmd | +vsplit +wincmd _ | wincmd | +vsplit +2wincmd h +wincmd w +wincmd w +let &splitbelow = s:save_splitbelow +let &splitright = s:save_splitright +wincmd t +let s:save_winminheight = &winminheight +let s:save_winminwidth = &winminwidth +set winminheight=0 +set winheight=1 +set winminwidth=0 +set winwidth=1 +exe 'vert 1resize ' . ((&columns * 31 + 137) / 274) +exe 'vert 2resize ' . ((&columns * 121 + 137) / 274) +exe 'vert 3resize ' . ((&columns * 120 + 137) / 274) +argglobal +enew +file NERD_tree_tab_1 +balt package.json +let s:cpo_save=&cpo +set cpo&vim +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap  :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap  :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap ? :call nerdtree#ui_glue#invokeKeyMap("?") +nnoremap A :call nerdtree#ui_glue#invokeKeyMap("A") +nnoremap B :call nerdtree#ui_glue#invokeKeyMap("B") +nnoremap C :call nerdtree#ui_glue#invokeKeyMap("C") +nnoremap CD :call nerdtree#ui_glue#invokeKeyMap("CD") +nnoremap D :call nerdtree#ui_glue#invokeKeyMap("D") +nnoremap FL :call nerdtree#ui_glue#invokeKeyMap("FL") +nnoremap F :call nerdtree#ui_glue#invokeKeyMap("F") +nnoremap I :call nerdtree#ui_glue#invokeKeyMap("I") +nnoremap J :call nerdtree#ui_glue#invokeKeyMap("J") +nnoremap K :call nerdtree#ui_glue#invokeKeyMap("K") +nnoremap O :call nerdtree#ui_glue#invokeKeyMap("O") +nnoremap P :call nerdtree#ui_glue#invokeKeyMap("P") +nnoremap R :call nerdtree#ui_glue#invokeKeyMap("R") +nnoremap T :call nerdtree#ui_glue#invokeKeyMap("T") +nnoremap U :call nerdtree#ui_glue#invokeKeyMap("U") +nnoremap X :call nerdtree#ui_glue#invokeKeyMap("X") +nnoremap cd :call nerdtree#ui_glue#invokeKeyMap("cd") +nnoremap e :call nerdtree#ui_glue#invokeKeyMap("e") +nnoremap f :call nerdtree#ui_glue#invokeKeyMap("f") +nnoremap go :call nerdtree#ui_glue#invokeKeyMap("go") +nnoremap gb :call nerdtree#ui_glue#invokeKeyMap("gb") +nnoremap gi :call nerdtree#ui_glue#invokeKeyMap("gi") +nnoremap gs :call nerdtree#ui_glue#invokeKeyMap("gs") +nnoremap i :call nerdtree#ui_glue#invokeKeyMap("i") +nnoremap m :call nerdtree#ui_glue#invokeKeyMap("m") +nnoremap o :call nerdtree#ui_glue#invokeKeyMap("o") +nnoremap p :call nerdtree#ui_glue#invokeKeyMap("p") +nnoremap q :call nerdtree#ui_glue#invokeKeyMap("q") +nnoremap r :call nerdtree#ui_glue#invokeKeyMap("r") +nnoremap s :call nerdtree#ui_glue#invokeKeyMap("s") +nnoremap t :call nerdtree#ui_glue#invokeKeyMap("t") +nnoremap u :call nerdtree#ui_glue#invokeKeyMap("u") +nnoremap x :call nerdtree#ui_glue#invokeKeyMap("x") +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap <2-LeftMouse> :call nerdtree#ui_glue#invokeKeyMap("<2-LeftMouse>") +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +let &cpo=s:cpo_save +unlet s:cpo_save +setlocal keymap= +setlocal noarabic +setlocal noautoindent +setlocal backupcopy= +setlocal balloonexpr= +setlocal nobinary +setlocal nobreakindent +setlocal breakindentopt= +setlocal bufhidden=hide +setlocal nobuflisted +setlocal buftype=nofile +setlocal nocindent +setlocal cinkeys=0{,0},0),0],:,0#,!^F,o,O,e +setlocal cinoptions= +setlocal cinscopedecls=public,protected,private +setlocal cinwords=if,else,while,do,for,switch +setlocal colorcolumn= +setlocal comments=s1:/*,mb:*,ex:*/,://,b:#,:%,:XCOMM,n:>,fb:- +setlocal commentstring=/*%s*/ +setlocal complete=.,w,b,u,t,i +setlocal concealcursor=nvic +setlocal conceallevel=2 +setlocal completefunc= +setlocal nocopyindent +setlocal cryptmethod= +setlocal nocursorbind +setlocal nocursorcolumn +setlocal cursorline +setlocal cursorlineopt=both +setlocal define= +setlocal dictionary= +setlocal nodiff +setlocal equalprg= +setlocal errorformat= +setlocal noexpandtab +if &filetype != 'nerdtree' +setlocal filetype=nerdtree +endif +setlocal fillchars= +setlocal fixendofline +setlocal foldcolumn=0 +setlocal nofoldenable +setlocal foldexpr=0 +setlocal foldignore=# +setlocal foldlevel=0 +setlocal foldmarker={{{,}}} +setlocal foldmethod=manual +setlocal foldminlines=1 +setlocal foldnestmax=20 +setlocal foldtext=foldtext() +setlocal formatexpr= +setlocal formatoptions=tcq +setlocal formatlistpat=^\\s*\\d\\+[\\]:.)}\\t\ ]\\s* +setlocal formatprg= +setlocal grepprg= +setlocal iminsert=0 +setlocal imsearch=-1 +setlocal include= +setlocal includeexpr= +setlocal indentexpr= +setlocal indentkeys=0{,0},0),0],:,0#,!^F,o,O,e +setlocal noinfercase +setlocal iskeyword=@,48-57,_,192-255 +setlocal keywordprg= +setlocal nolinebreak +setlocal nolisp +setlocal lispoptions= +setlocal lispwords= +setlocal nolist +setlocal listchars= +setlocal makeencoding= +setlocal makeprg= +setlocal matchpairs=(:),{:},[:] +setlocal nomodeline +setlocal nomodifiable +setlocal nrformats=bin,octal,hex +set number +setlocal nonumber +setlocal numberwidth=4 +setlocal omnifunc= +setlocal path= +setlocal nopreserveindent +setlocal nopreviewwindow +setlocal quoteescape=\\ +setlocal readonly +setlocal norelativenumber +setlocal norightleft +setlocal rightleftcmd=search +setlocal noscrollbind +setlocal scrolloff=-1 +setlocal shiftwidth=4 +setlocal noshortname +setlocal showbreak= +setlocal sidescrolloff=-1 +set signcolumn=yes +setlocal signcolumn=yes +setlocal nosmartindent +setlocal nosmoothscroll +setlocal softtabstop=0 +setlocal nospell +setlocal spellcapcheck=[.?!]\\_[\\])'\"\ \ ]\\+ +setlocal spellfile= +setlocal spelllang=en +setlocal spelloptions= +setlocal statusline=%{exists('b:NERDTree')?b:NERDTree.root.path.str():''} +setlocal suffixesadd= +setlocal noswapfile +setlocal synmaxcol=3000 +if &syntax != 'nerdtree' +setlocal syntax=nerdtree +endif +setlocal tabstop=8 +setlocal tagcase= +setlocal tagfunc= +setlocal tags= +setlocal termwinkey= +setlocal termwinscroll=10000 +setlocal termwinsize= +setlocal textwidth=0 +setlocal thesaurus= +setlocal thesaurusfunc= +setlocal noundofile +setlocal undolevels=-123456 +setlocal varsofttabstop= +setlocal vartabstop= +setlocal virtualedit= +setlocal wincolor= +setlocal nowinfixheight +setlocal winfixwidth +setlocal nowrap +setlocal wrapmargin=0 +wincmd w +argglobal +balt package.json +let s:cpo_save=&cpo +set cpo&vim +nmap [c (GitGutterPrevHunk) +nmap \hp (GitGutterPreviewHunk) +nmap \hu (GitGutterUndoHunk) +nmap \hs (GitGutterStageHunk) +xmap \hs (GitGutterStageHunk) +nmap ]c (GitGutterNextHunk) +xmap ac (GitGutterTextObjectOuterVisual) +omap ac (GitGutterTextObjectOuterPending) +xmap ic (GitGutterTextObjectInnerVisual) +omap ic (GitGutterTextObjectInnerPending) +let &cpo=s:cpo_save +unlet s:cpo_save +setlocal keymap= +setlocal noarabic +setlocal noautoindent +setlocal backupcopy= +setlocal balloonexpr= +setlocal nobinary +setlocal nobreakindent +setlocal breakindentopt= +setlocal bufhidden= +setlocal buflisted +setlocal buftype= +setlocal nocindent +setlocal cinkeys=0{,0},0),0],:,0#,!^F,o,O,e +setlocal cinoptions= +setlocal cinscopedecls=public,protected,private +setlocal cinwords=if,else,while,do,for,switch +setlocal colorcolumn= +setlocal comments= +setlocal commentstring= +setlocal complete=.,w,b,u,t,i +setlocal concealcursor= +setlocal conceallevel=0 +setlocal completefunc= +setlocal nocopyindent +setlocal cryptmethod= +setlocal nocursorbind +setlocal nocursorcolumn +setlocal nocursorline +setlocal cursorlineopt=both +setlocal define= +setlocal dictionary= +setlocal nodiff +setlocal equalprg= +setlocal errorformat= +setlocal noexpandtab +if &filetype != 'json' +setlocal filetype=json +endif +setlocal fillchars= +setlocal fixendofline +setlocal foldcolumn=0 +setlocal foldenable +setlocal foldexpr=0 +setlocal foldignore=# +setlocal foldlevel=0 +setlocal foldmarker={{{,}}} +setlocal foldmethod=manual +setlocal foldminlines=1 +setlocal foldnestmax=20 +setlocal foldtext=foldtext() +setlocal formatexpr= +setlocal formatoptions=cq +setlocal formatlistpat=^\\s*\\d\\+[\\]:.)}\\t\ ]\\s* +setlocal formatprg= +setlocal grepprg= +setlocal iminsert=0 +setlocal imsearch=-1 +setlocal include= +setlocal includeexpr= +setlocal indentexpr=GetJSONIndent(v:lnum) +setlocal indentkeys=0{,0},0),0[,0],!^F,o,O,e +setlocal noinfercase +setlocal iskeyword=@,48-57,_,192-255 +setlocal keywordprg= +setlocal nolinebreak +setlocal nolisp +setlocal lispoptions= +setlocal lispwords= +setlocal nolist +setlocal listchars= +setlocal makeencoding= +setlocal makeprg= +setlocal matchpairs=(:),{:},[:] +setlocal nomodeline +setlocal modifiable +setlocal nrformats=bin,octal,hex +set number +setlocal number +setlocal numberwidth=4 +setlocal omnifunc= +setlocal path= +setlocal nopreserveindent +setlocal nopreviewwindow +setlocal quoteescape=\\ +setlocal noreadonly +setlocal norelativenumber +setlocal norightleft +setlocal rightleftcmd=search +setlocal noscrollbind +setlocal scrolloff=-1 +setlocal shiftwidth=4 +setlocal noshortname +setlocal showbreak= +setlocal sidescrolloff=-1 +set signcolumn=yes +setlocal signcolumn=yes +setlocal nosmartindent +setlocal nosmoothscroll +setlocal softtabstop=0 +setlocal nospell +setlocal spellcapcheck=[.?!]\\_[\\])'\"\ \ ]\\+ +setlocal spellfile= +setlocal spelllang=en +setlocal spelloptions= +setlocal statusline= +setlocal suffixesadd= +setlocal swapfile +setlocal synmaxcol=3000 +if &syntax != 'json' +setlocal syntax=json +endif +setlocal tabstop=8 +setlocal tagcase= +setlocal tagfunc= +setlocal tags= +setlocal termwinkey= +setlocal termwinscroll=10000 +setlocal termwinsize= +setlocal textwidth=0 +setlocal thesaurus= +setlocal thesaurusfunc= +setlocal noundofile +setlocal undolevels=-123456 +setlocal varsofttabstop= +setlocal vartabstop= +setlocal virtualedit= +setlocal wincolor= +setlocal nowinfixheight +setlocal nowinfixwidth +setlocal wrap +setlocal wrapmargin=0 +silent! normal! zE +let &fdl = &fdl +let s:l = 16 - ((15 * winheight(0) + 18) / 37) +if s:l < 1 | let s:l = 1 | endif +keepjumps exe s:l +normal! zt +keepjumps 16 +normal! $ +wincmd w +argglobal +if bufexists(fnamemodify("README.md", ":p")) | buffer README.md | else | edit README.md | endif +balt package.json +let s:cpo_save=&cpo +set cpo&vim +nmap [c (GitGutterPrevHunk) +xnoremap [[ :exe "normal! gv"|call search('\%(^#\{1,5\}\s\+\S\|^\S.*\n^[=-]\+$\)', "bsW") +nnoremap [[ :call search('\%(^#\{1,5\}\s\+\S\|^\S.*\n^[=-]\+$\)', "bsW") +nmap \hp (GitGutterPreviewHunk) +nmap \hu (GitGutterUndoHunk) +nmap \hs (GitGutterStageHunk) +xmap \hs (GitGutterStageHunk) +nmap ]c (GitGutterNextHunk) +xnoremap ]] :exe "normal! gv"|call search('\%(^#\{1,5\}\s\+\S\|^\S.*\n^[=-]\+$\)', "sW") +nnoremap ]] :call search('\%(^#\{1,5\}\s\+\S\|^\S.*\n^[=-]\+$\)', "sW") +xmap ac (GitGutterTextObjectOuterVisual) +omap ac (GitGutterTextObjectOuterPending) +xmap ic (GitGutterTextObjectInnerVisual) +omap ic (GitGutterTextObjectInnerPending) +let &cpo=s:cpo_save +unlet s:cpo_save +setlocal keymap= +setlocal noarabic +setlocal noautoindent +setlocal backupcopy= +setlocal balloonexpr= +setlocal nobinary +setlocal nobreakindent +setlocal breakindentopt= +setlocal bufhidden= +setlocal buflisted +setlocal buftype= +setlocal nocindent +setlocal cinkeys=0{,0},0),0],:,0#,!^F,o,O,e +setlocal cinoptions= +setlocal cinscopedecls=public,protected,private +setlocal cinwords=if,else,while,do,for,switch +setlocal colorcolumn= +setlocal comments=fb:*,fb:-,fb:+,n:> +setlocal commentstring= +setlocal complete=.,w,b,u,t,i +setlocal concealcursor= +setlocal conceallevel=0 +setlocal completefunc= +setlocal nocopyindent +setlocal cryptmethod= +setlocal nocursorbind +setlocal nocursorcolumn +setlocal nocursorline +setlocal cursorlineopt=both +setlocal define= +setlocal dictionary= +setlocal nodiff +setlocal equalprg= +setlocal errorformat= +setlocal expandtab +if &filetype != 'markdown' +setlocal filetype=markdown +endif +setlocal fillchars= +setlocal fixendofline +setlocal foldcolumn=0 +setlocal foldenable +setlocal foldexpr=0 +setlocal foldignore=# +setlocal foldlevel=0 +setlocal foldmarker={{{,}}} +setlocal foldmethod=manual +setlocal foldminlines=1 +setlocal foldnestmax=20 +setlocal foldtext=foldtext() +setlocal formatexpr= +setlocal formatoptions=tcqln +setlocal formatlistpat=^\\s*\\d\\+\\.\\s\\+\\|^\\s*[-*+]\\s\\+\\|^\\[^\\ze[^\\]]\\+\\]:\\&^.\\{4\\} +setlocal formatprg= +setlocal grepprg= +setlocal iminsert=0 +setlocal imsearch=-1 +setlocal include= +setlocal includeexpr= +setlocal indentexpr= +setlocal indentkeys=0{,0},0),0],:,0#,!^F,o,O,e +setlocal noinfercase +setlocal iskeyword=@,48-57,_,192-255 +setlocal keywordprg= +setlocal nolinebreak +setlocal nolisp +setlocal lispoptions= +setlocal lispwords= +setlocal nolist +setlocal listchars= +setlocal makeencoding= +setlocal makeprg= +setlocal matchpairs=(:),{:},[:],<:> +setlocal nomodeline +setlocal modifiable +setlocal nrformats=bin,octal,hex +set number +setlocal number +setlocal numberwidth=4 +setlocal omnifunc=htmlcomplete#CompleteTags +setlocal path= +setlocal nopreserveindent +setlocal nopreviewwindow +setlocal quoteescape=\\ +setlocal noreadonly +setlocal norelativenumber +setlocal norightleft +setlocal rightleftcmd=search +setlocal noscrollbind +setlocal scrolloff=-1 +setlocal shiftwidth=4 +setlocal noshortname +setlocal showbreak= +setlocal sidescrolloff=-1 +set signcolumn=yes +setlocal signcolumn=yes +setlocal nosmartindent +setlocal nosmoothscroll +setlocal softtabstop=4 +setlocal nospell +setlocal spellcapcheck=[.?!]\\_[\\])'\"\ \ ]\\+ +setlocal spellfile= +setlocal spelllang=en +setlocal spelloptions= +setlocal statusline= +setlocal suffixesadd= +setlocal swapfile +setlocal synmaxcol=3000 +if &syntax != 'markdown' +setlocal syntax=markdown +endif +setlocal tabstop=4 +setlocal tagcase= +setlocal tagfunc= +setlocal tags= +setlocal termwinkey= +setlocal termwinscroll=10000 +setlocal termwinsize= +setlocal textwidth=0 +setlocal thesaurus= +setlocal thesaurusfunc= +setlocal noundofile +setlocal undolevels=-123456 +setlocal varsofttabstop= +setlocal vartabstop= +setlocal virtualedit= +setlocal wincolor= +setlocal nowinfixheight +setlocal nowinfixwidth +setlocal wrap +setlocal wrapmargin=0 +silent! normal! zE +let &fdl = &fdl +let s:l = 242 - ((35 * winheight(0) + 18) / 37) +if s:l < 1 | let s:l = 1 | endif +keepjumps exe s:l +normal! zt +keepjumps 242 +normal! 0154| +wincmd w +exe 'vert 1resize ' . ((&columns * 31 + 137) / 274) +exe 'vert 2resize ' . ((&columns * 121 + 137) / 274) +exe 'vert 3resize ' . ((&columns * 120 + 137) / 274) +tabnext +edit static/src/index.tsx +let s:save_splitbelow = &splitbelow +let s:save_splitright = &splitright +set splitbelow splitright +wincmd _ | wincmd | +vsplit +wincmd _ | wincmd | +vsplit +2wincmd h +wincmd w +wincmd w +let &splitbelow = s:save_splitbelow +let &splitright = s:save_splitright +wincmd t +let s:save_winminheight = &winminheight +let s:save_winminwidth = &winminwidth +set winminheight=0 +set winheight=1 +set winminwidth=0 +set winwidth=1 +exe 'vert 1resize ' . ((&columns * 31 + 137) / 274) +exe 'vert 2resize ' . ((&columns * 121 + 137) / 274) +exe 'vert 3resize ' . ((&columns * 120 + 137) / 274) +argglobal +enew +file NERD_tree_tab_2 +balt static/src/index.tsx +let s:cpo_save=&cpo +set cpo&vim +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap  :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap  :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap ? :call nerdtree#ui_glue#invokeKeyMap("?") +nnoremap A :call nerdtree#ui_glue#invokeKeyMap("A") +nnoremap B :call nerdtree#ui_glue#invokeKeyMap("B") +nnoremap C :call nerdtree#ui_glue#invokeKeyMap("C") +nnoremap CD :call nerdtree#ui_glue#invokeKeyMap("CD") +nnoremap D :call nerdtree#ui_glue#invokeKeyMap("D") +nnoremap FL :call nerdtree#ui_glue#invokeKeyMap("FL") +nnoremap F :call nerdtree#ui_glue#invokeKeyMap("F") +nnoremap I :call nerdtree#ui_glue#invokeKeyMap("I") +nnoremap J :call nerdtree#ui_glue#invokeKeyMap("J") +nnoremap K :call nerdtree#ui_glue#invokeKeyMap("K") +nnoremap O :call nerdtree#ui_glue#invokeKeyMap("O") +nnoremap P :call nerdtree#ui_glue#invokeKeyMap("P") +nnoremap R :call nerdtree#ui_glue#invokeKeyMap("R") +nnoremap T :call nerdtree#ui_glue#invokeKeyMap("T") +nnoremap U :call nerdtree#ui_glue#invokeKeyMap("U") +nnoremap X :call nerdtree#ui_glue#invokeKeyMap("X") +nmap [c (GitGutterPrevHunk) +nmap \hp (GitGutterPreviewHunk) +nmap \hu (GitGutterUndoHunk) +nmap \hs (GitGutterStageHunk) +xmap \hs (GitGutterStageHunk) +nmap ]c (GitGutterNextHunk) +xmap ac (GitGutterTextObjectOuterVisual) +omap ac (GitGutterTextObjectOuterPending) +nnoremap cd :call nerdtree#ui_glue#invokeKeyMap("cd") +nnoremap e :call nerdtree#ui_glue#invokeKeyMap("e") +nnoremap f :call nerdtree#ui_glue#invokeKeyMap("f") +nnoremap go :call nerdtree#ui_glue#invokeKeyMap("go") +nnoremap gb :call nerdtree#ui_glue#invokeKeyMap("gb") +nnoremap gi :call nerdtree#ui_glue#invokeKeyMap("gi") +nnoremap gs :call nerdtree#ui_glue#invokeKeyMap("gs") +nnoremap i :call nerdtree#ui_glue#invokeKeyMap("i") +xmap ic (GitGutterTextObjectInnerVisual) +omap ic (GitGutterTextObjectInnerPending) +nnoremap m :call nerdtree#ui_glue#invokeKeyMap("m") +nnoremap o :call nerdtree#ui_glue#invokeKeyMap("o") +nnoremap p :call nerdtree#ui_glue#invokeKeyMap("p") +nnoremap q :call nerdtree#ui_glue#invokeKeyMap("q") +nnoremap r :call nerdtree#ui_glue#invokeKeyMap("r") +nnoremap s :call nerdtree#ui_glue#invokeKeyMap("s") +nnoremap t :call nerdtree#ui_glue#invokeKeyMap("t") +nnoremap u :call nerdtree#ui_glue#invokeKeyMap("u") +nnoremap x :call nerdtree#ui_glue#invokeKeyMap("x") +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap <2-LeftMouse> :call nerdtree#ui_glue#invokeKeyMap("<2-LeftMouse>") +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +let &cpo=s:cpo_save +unlet s:cpo_save +setlocal keymap= +setlocal noarabic +setlocal noautoindent +setlocal backupcopy= +setlocal balloonexpr= +setlocal nobinary +setlocal nobreakindent +setlocal breakindentopt= +setlocal bufhidden=hide +setlocal nobuflisted +setlocal buftype=nofile +setlocal nocindent +setlocal cinkeys=0{,0},0),0],:,0#,!^F,o,O,e +setlocal cinoptions= +setlocal cinscopedecls=public,protected,private +setlocal cinwords=if,else,while,do,for,switch +setlocal colorcolumn= +setlocal comments=s1:/*,mb:*,ex:*/,://,b:#,:%,:XCOMM,n:>,fb:- +setlocal commentstring=/*%s*/ +setlocal complete=.,w,b,u,t,i +setlocal concealcursor=nvic +setlocal conceallevel=2 +setlocal completefunc= +setlocal nocopyindent +setlocal cryptmethod= +setlocal nocursorbind +setlocal nocursorcolumn +setlocal cursorline +setlocal cursorlineopt=both +setlocal define= +setlocal dictionary= +setlocal nodiff +setlocal equalprg= +setlocal errorformat= +setlocal noexpandtab +if &filetype != 'nerdtree' +setlocal filetype=nerdtree +endif +setlocal fillchars= +setlocal fixendofline +setlocal foldcolumn=0 +setlocal nofoldenable +setlocal foldexpr=0 +setlocal foldignore=# +setlocal foldlevel=0 +setlocal foldmarker={{{,}}} +setlocal foldmethod=manual +setlocal foldminlines=1 +setlocal foldnestmax=20 +setlocal foldtext=foldtext() +setlocal formatexpr= +setlocal formatoptions=tcq +setlocal formatlistpat=^\\s*\\d\\+[\\]:.)}\\t\ ]\\s* +setlocal formatprg= +setlocal grepprg= +setlocal iminsert=0 +setlocal imsearch=-1 +setlocal include= +setlocal includeexpr= +setlocal indentexpr= +setlocal indentkeys=0{,0},0),0],:,0#,!^F,o,O,e +setlocal noinfercase +setlocal iskeyword=@,48-57,_,192-255 +setlocal keywordprg= +setlocal nolinebreak +setlocal nolisp +setlocal lispoptions= +setlocal lispwords= +setlocal nolist +setlocal listchars= +setlocal makeencoding= +setlocal makeprg= +setlocal matchpairs=(:),{:},[:] +setlocal nomodeline +setlocal nomodifiable +setlocal nrformats=bin,octal,hex +set number +setlocal nonumber +setlocal numberwidth=4 +setlocal omnifunc= +setlocal path= +setlocal nopreserveindent +setlocal nopreviewwindow +setlocal quoteescape=\\ +setlocal readonly +setlocal norelativenumber +setlocal norightleft +setlocal rightleftcmd=search +setlocal noscrollbind +setlocal scrolloff=-1 +setlocal shiftwidth=4 +setlocal noshortname +setlocal showbreak= +setlocal sidescrolloff=-1 +set signcolumn=yes +setlocal signcolumn=yes +setlocal nosmartindent +setlocal nosmoothscroll +setlocal softtabstop=0 +setlocal nospell +setlocal spellcapcheck=[.?!]\\_[\\])'\"\ \ ]\\+ +setlocal spellfile= +setlocal spelllang=en +setlocal spelloptions= +setlocal statusline=%{exists('b:NERDTree')?b:NERDTree.root.path.str():''} +setlocal suffixesadd= +setlocal noswapfile +setlocal synmaxcol=3000 +if &syntax != 'nerdtree' +setlocal syntax=nerdtree +endif +setlocal tabstop=8 +setlocal tagcase= +setlocal tagfunc= +setlocal tags= +setlocal termwinkey= +setlocal termwinscroll=10000 +setlocal termwinsize= +setlocal textwidth=0 +setlocal thesaurus= +setlocal thesaurusfunc= +setlocal noundofile +setlocal undolevels=-123456 +setlocal varsofttabstop= +setlocal vartabstop= +setlocal virtualedit= +setlocal wincolor= +setlocal nowinfixheight +setlocal winfixwidth +setlocal nowrap +setlocal wrapmargin=0 +wincmd w +argglobal +balt package.json +let s:cpo_save=&cpo +set cpo&vim +nmap [c (GitGutterPrevHunk) +nmap \hp (GitGutterPreviewHunk) +nmap \hu (GitGutterUndoHunk) +nmap \hs (GitGutterStageHunk) +xmap \hs (GitGutterStageHunk) +nmap ]c (GitGutterNextHunk) +xmap ac (GitGutterTextObjectOuterVisual) +omap ac (GitGutterTextObjectOuterPending) +xmap ic (GitGutterTextObjectInnerVisual) +omap ic (GitGutterTextObjectInnerPending) +let &cpo=s:cpo_save +unlet s:cpo_save +setlocal keymap= +setlocal noarabic +setlocal autoindent +setlocal backupcopy= +setlocal balloonexpr= +setlocal nobinary +setlocal nobreakindent +setlocal breakindentopt= +setlocal bufhidden= +setlocal buflisted +setlocal buftype= +setlocal nocindent +setlocal cinkeys=0{,0},0),0],:,0#,!^F,o,O,e +setlocal cinoptions= +setlocal cinscopedecls=public,protected,private +setlocal cinwords=if,else,while,do,for,switch +setlocal colorcolumn= +setlocal comments=s1:/*,mb:*,ex:*/,://,b:#,:%,:XCOMM,n:>,fb:- +setlocal commentstring=//\ %s +setlocal complete=.,w,b,u,t,i +setlocal concealcursor= +setlocal conceallevel=0 +setlocal completefunc= +setlocal nocopyindent +setlocal cryptmethod= +setlocal nocursorbind +setlocal nocursorcolumn +setlocal nocursorline +setlocal cursorlineopt=both +setlocal define= +setlocal dictionary= +setlocal nodiff +setlocal equalprg= +setlocal errorformat=%+A\ %#%f\ %#(%l\\,%c):\ %m,%C%m +setlocal noexpandtab +if &filetype != 'typescriptreact' +setlocal filetype=typescriptreact +endif +setlocal fillchars= +setlocal fixendofline +setlocal foldcolumn=0 +setlocal foldenable +setlocal foldexpr=0 +setlocal foldignore=# +setlocal foldlevel=0 +setlocal foldmarker={{{,}}} +setlocal foldmethod=manual +setlocal foldminlines=1 +setlocal foldnestmax=20 +setlocal foldtext=foldtext() +setlocal formatexpr= +setlocal formatoptions=croql +setlocal formatlistpat=^\\s*\\d\\+[\\]:.)}\\t\ ]\\s* +setlocal formatprg= +setlocal grepprg= +setlocal iminsert=0 +setlocal imsearch=-1 +setlocal include= +setlocal includeexpr= +setlocal indentexpr=GetTsxIndent() +setlocal indentkeys=0{,0},0),0],0,,!^F,o,O,e,*,<>>,<<>,/ +setlocal noinfercase +setlocal iskeyword=@,48-57,_,192-255,$ +setlocal keywordprg= +setlocal nolinebreak +setlocal nolisp +setlocal lispoptions= +setlocal lispwords= +setlocal nolist +setlocal listchars= +setlocal makeencoding= +setlocal makeprg=tsc\ \ $*\ % +setlocal matchpairs=(:),{:},[:] +setlocal nomodeline +setlocal modifiable +setlocal nrformats=bin,octal,hex +set number +setlocal number +setlocal numberwidth=4 +setlocal omnifunc= +setlocal path= +setlocal nopreserveindent +setlocal nopreviewwindow +setlocal quoteescape=\\ +setlocal noreadonly +setlocal norelativenumber +setlocal norightleft +setlocal rightleftcmd=search +setlocal noscrollbind +setlocal scrolloff=-1 +setlocal shiftwidth=4 +setlocal noshortname +setlocal showbreak= +setlocal sidescrolloff=-1 +set signcolumn=yes +setlocal signcolumn=yes +setlocal nosmartindent +setlocal nosmoothscroll +setlocal softtabstop=0 +setlocal nospell +setlocal spellcapcheck=[.?!]\\_[\\])'\"\ \ ]\\+ +setlocal spellfile= +setlocal spelllang=en +setlocal spelloptions= +setlocal statusline= +setlocal suffixesadd=.ts,.tsx +setlocal swapfile +setlocal synmaxcol=3000 +if &syntax != 'typescriptreact' +setlocal syntax=typescriptreact +endif +setlocal tabstop=8 +setlocal tagcase= +setlocal tagfunc= +setlocal tags= +setlocal termwinkey= +setlocal termwinscroll=10000 +setlocal termwinsize= +setlocal textwidth=0 +setlocal thesaurus= +setlocal thesaurusfunc= +setlocal noundofile +setlocal undolevels=-123456 +setlocal varsofttabstop= +setlocal vartabstop= +setlocal virtualedit= +setlocal wincolor= +setlocal nowinfixheight +setlocal nowinfixwidth +setlocal wrap +setlocal wrapmargin=0 +silent! normal! zE +let &fdl = &fdl +let s:l = 17 - ((16 * winheight(0) + 18) / 37) +if s:l < 1 | let s:l = 1 | endif +keepjumps exe s:l +normal! zt +keepjumps 17 +normal! $ +wincmd w +argglobal +if bufexists(fnamemodify("static/src/translations.tsx", ":p")) | buffer static/src/translations.tsx | else | edit static/src/translations.tsx | endif +balt static/src/index.tsx +let s:cpo_save=&cpo +set cpo&vim +nmap [c (GitGutterPrevHunk) +nmap \hp (GitGutterPreviewHunk) +nmap \hu (GitGutterUndoHunk) +nmap \hs (GitGutterStageHunk) +xmap \hs (GitGutterStageHunk) +nmap ]c (GitGutterNextHunk) +xmap ac (GitGutterTextObjectOuterVisual) +omap ac (GitGutterTextObjectOuterPending) +xmap ic (GitGutterTextObjectInnerVisual) +omap ic (GitGutterTextObjectInnerPending) +let &cpo=s:cpo_save +unlet s:cpo_save +setlocal keymap= +setlocal noarabic +setlocal autoindent +setlocal backupcopy= +setlocal balloonexpr= +setlocal nobinary +setlocal nobreakindent +setlocal breakindentopt= +setlocal bufhidden= +setlocal buflisted +setlocal buftype= +setlocal nocindent +setlocal cinkeys=0{,0},0),0],:,0#,!^F,o,O,e +setlocal cinoptions= +setlocal cinscopedecls=public,protected,private +setlocal cinwords=if,else,while,do,for,switch +setlocal colorcolumn= +setlocal comments=s1:/*,mb:*,ex:*/,://,b:#,:%,:XCOMM,n:>,fb:- +setlocal commentstring=//\ %s +setlocal complete=.,w,b,u,t,i +setlocal concealcursor= +setlocal conceallevel=0 +setlocal completefunc= +setlocal nocopyindent +setlocal cryptmethod= +setlocal nocursorbind +setlocal nocursorcolumn +setlocal nocursorline +setlocal cursorlineopt=both +setlocal define= +setlocal dictionary= +setlocal nodiff +setlocal equalprg= +setlocal errorformat=%+A\ %#%f\ %#(%l\\,%c):\ %m,%C%m +setlocal noexpandtab +if &filetype != 'typescriptreact' +setlocal filetype=typescriptreact +endif +setlocal fillchars= +setlocal fixendofline +setlocal foldcolumn=0 +setlocal foldenable +setlocal foldexpr=0 +setlocal foldignore=# +setlocal foldlevel=0 +setlocal foldmarker={{{,}}} +setlocal foldmethod=manual +setlocal foldminlines=1 +setlocal foldnestmax=20 +setlocal foldtext=foldtext() +setlocal formatexpr= +setlocal formatoptions=croql +setlocal formatlistpat=^\\s*\\d\\+[\\]:.)}\\t\ ]\\s* +setlocal formatprg= +setlocal grepprg= +setlocal iminsert=0 +setlocal imsearch=-1 +setlocal include= +setlocal includeexpr= +setlocal indentexpr=GetTsxIndent() +setlocal indentkeys=0{,0},0),0],0,,!^F,o,O,e,*,<>>,<<>,/ +setlocal noinfercase +setlocal iskeyword=@,48-57,_,192-255,$ +setlocal keywordprg= +setlocal nolinebreak +setlocal nolisp +setlocal lispoptions= +setlocal lispwords= +setlocal nolist +setlocal listchars= +setlocal makeencoding= +setlocal makeprg=tsc\ \ $*\ % +setlocal matchpairs=(:),{:},[:] +setlocal nomodeline +setlocal modifiable +setlocal nrformats=bin,octal,hex +set number +setlocal number +setlocal numberwidth=4 +setlocal omnifunc= +setlocal path= +setlocal nopreserveindent +setlocal nopreviewwindow +setlocal quoteescape=\\ +setlocal noreadonly +setlocal norelativenumber +setlocal norightleft +setlocal rightleftcmd=search +setlocal noscrollbind +setlocal scrolloff=-1 +setlocal shiftwidth=4 +setlocal noshortname +setlocal showbreak= +setlocal sidescrolloff=-1 +set signcolumn=yes +setlocal signcolumn=yes +setlocal nosmartindent +setlocal nosmoothscroll +setlocal softtabstop=0 +setlocal nospell +setlocal spellcapcheck=[.?!]\\_[\\])'\"\ \ ]\\+ +setlocal spellfile= +setlocal spelllang=en +setlocal spelloptions= +setlocal statusline= +setlocal suffixesadd=.ts,.tsx +setlocal swapfile +setlocal synmaxcol=3000 +if &syntax != 'typescriptreact' +setlocal syntax=typescriptreact +endif +setlocal tabstop=8 +setlocal tagcase= +setlocal tagfunc= +setlocal tags= +setlocal termwinkey= +setlocal termwinscroll=10000 +setlocal termwinsize= +setlocal textwidth=0 +setlocal thesaurus= +setlocal thesaurusfunc= +setlocal noundofile +setlocal undolevels=-123456 +setlocal varsofttabstop= +setlocal vartabstop= +setlocal virtualedit= +setlocal wincolor= +setlocal nowinfixheight +setlocal nowinfixwidth +setlocal wrap +setlocal wrapmargin=0 +silent! normal! zE +let &fdl = &fdl +let s:l = 26 - ((25 * winheight(0) + 18) / 37) +if s:l < 1 | let s:l = 1 | endif +keepjumps exe s:l +normal! zt +keepjumps 26 +normal! 059| +wincmd w +exe 'vert 1resize ' . ((&columns * 31 + 137) / 274) +exe 'vert 2resize ' . ((&columns * 121 + 137) / 274) +exe 'vert 3resize ' . ((&columns * 120 + 137) / 274) +tabnext +edit utility.ts +let s:save_splitbelow = &splitbelow +let s:save_splitright = &splitright +set splitbelow splitright +wincmd _ | wincmd | +vsplit +wincmd _ | wincmd | +vsplit +2wincmd h +wincmd w +wincmd w +let &splitbelow = s:save_splitbelow +let &splitright = s:save_splitright +wincmd t +let s:save_winminheight = &winminheight +let s:save_winminwidth = &winminwidth +set winminheight=0 +set winheight=1 +set winminwidth=0 +set winwidth=1 +exe 'vert 1resize ' . ((&columns * 31 + 137) / 274) +exe 'vert 2resize ' . ((&columns * 120 + 137) / 274) +exe 'vert 3resize ' . ((&columns * 121 + 137) / 274) +argglobal +enew +file NERD_tree_tab_3 +balt utility.ts +let s:cpo_save=&cpo +set cpo&vim +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap  :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap  :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap ? :call nerdtree#ui_glue#invokeKeyMap("?") +nnoremap A :call nerdtree#ui_glue#invokeKeyMap("A") +nnoremap B :call nerdtree#ui_glue#invokeKeyMap("B") +nnoremap C :call nerdtree#ui_glue#invokeKeyMap("C") +nnoremap CD :call nerdtree#ui_glue#invokeKeyMap("CD") +nnoremap D :call nerdtree#ui_glue#invokeKeyMap("D") +nnoremap FL :call nerdtree#ui_glue#invokeKeyMap("FL") +nnoremap F :call nerdtree#ui_glue#invokeKeyMap("F") +nnoremap I :call nerdtree#ui_glue#invokeKeyMap("I") +nnoremap J :call nerdtree#ui_glue#invokeKeyMap("J") +nnoremap K :call nerdtree#ui_glue#invokeKeyMap("K") +nnoremap O :call nerdtree#ui_glue#invokeKeyMap("O") +nnoremap P :call nerdtree#ui_glue#invokeKeyMap("P") +nnoremap R :call nerdtree#ui_glue#invokeKeyMap("R") +nnoremap T :call nerdtree#ui_glue#invokeKeyMap("T") +nnoremap U :call nerdtree#ui_glue#invokeKeyMap("U") +nnoremap X :call nerdtree#ui_glue#invokeKeyMap("X") +nmap [c (GitGutterPrevHunk) +nmap \hp (GitGutterPreviewHunk) +nmap \hu (GitGutterUndoHunk) +nmap \hs (GitGutterStageHunk) +xmap \hs (GitGutterStageHunk) +nmap ]c (GitGutterNextHunk) +xmap ac (GitGutterTextObjectOuterVisual) +omap ac (GitGutterTextObjectOuterPending) +nnoremap cd :call nerdtree#ui_glue#invokeKeyMap("cd") +nnoremap e :call nerdtree#ui_glue#invokeKeyMap("e") +nnoremap f :call nerdtree#ui_glue#invokeKeyMap("f") +nnoremap go :call nerdtree#ui_glue#invokeKeyMap("go") +nnoremap gb :call nerdtree#ui_glue#invokeKeyMap("gb") +nnoremap gi :call nerdtree#ui_glue#invokeKeyMap("gi") +nnoremap gs :call nerdtree#ui_glue#invokeKeyMap("gs") +nnoremap i :call nerdtree#ui_glue#invokeKeyMap("i") +xmap ic (GitGutterTextObjectInnerVisual) +omap ic (GitGutterTextObjectInnerPending) +nnoremap m :call nerdtree#ui_glue#invokeKeyMap("m") +nnoremap o :call nerdtree#ui_glue#invokeKeyMap("o") +nnoremap p :call nerdtree#ui_glue#invokeKeyMap("p") +nnoremap q :call nerdtree#ui_glue#invokeKeyMap("q") +nnoremap r :call nerdtree#ui_glue#invokeKeyMap("r") +nnoremap s :call nerdtree#ui_glue#invokeKeyMap("s") +nnoremap t :call nerdtree#ui_glue#invokeKeyMap("t") +nnoremap u :call nerdtree#ui_glue#invokeKeyMap("u") +nnoremap x :call nerdtree#ui_glue#invokeKeyMap("x") +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap <2-LeftMouse> :call nerdtree#ui_glue#invokeKeyMap("<2-LeftMouse>") +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +nnoremap :call nerdtree#ui_glue#invokeKeyMap("") +let &cpo=s:cpo_save +unlet s:cpo_save +setlocal keymap= +setlocal noarabic +setlocal noautoindent +setlocal backupcopy= +setlocal balloonexpr= +setlocal nobinary +setlocal nobreakindent +setlocal breakindentopt= +setlocal bufhidden=hide +setlocal nobuflisted +setlocal buftype=nofile +setlocal nocindent +setlocal cinkeys=0{,0},0),0],:,0#,!^F,o,O,e +setlocal cinoptions= +setlocal cinscopedecls=public,protected,private +setlocal cinwords=if,else,while,do,for,switch +setlocal colorcolumn= +setlocal comments=s1:/*,mb:*,ex:*/,://,b:#,:%,:XCOMM,n:>,fb:- +setlocal commentstring=/*%s*/ +setlocal complete=.,w,b,u,t,i +setlocal concealcursor=nvic +setlocal conceallevel=2 +setlocal completefunc= +setlocal nocopyindent +setlocal cryptmethod= +setlocal nocursorbind +setlocal nocursorcolumn +setlocal cursorline +setlocal cursorlineopt=both +setlocal define= +setlocal dictionary= +setlocal nodiff +setlocal equalprg= +setlocal errorformat= +setlocal noexpandtab +if &filetype != 'nerdtree' +setlocal filetype=nerdtree +endif +setlocal fillchars= +setlocal fixendofline +setlocal foldcolumn=0 +setlocal nofoldenable +setlocal foldexpr=0 +setlocal foldignore=# +setlocal foldlevel=0 +setlocal foldmarker={{{,}}} +setlocal foldmethod=manual +setlocal foldminlines=1 +setlocal foldnestmax=20 +setlocal foldtext=foldtext() +setlocal formatexpr= +setlocal formatoptions=tcq +setlocal formatlistpat=^\\s*\\d\\+[\\]:.)}\\t\ ]\\s* +setlocal formatprg= +setlocal grepprg= +setlocal iminsert=0 +setlocal imsearch=-1 +setlocal include= +setlocal includeexpr= +setlocal indentexpr= +setlocal indentkeys=0{,0},0),0],:,0#,!^F,o,O,e +setlocal noinfercase +setlocal iskeyword=@,48-57,_,192-255 +setlocal keywordprg= +setlocal nolinebreak +setlocal nolisp +setlocal lispoptions= +setlocal lispwords= +setlocal nolist +setlocal listchars= +setlocal makeencoding= +setlocal makeprg= +setlocal matchpairs=(:),{:},[:] +setlocal nomodeline +setlocal nomodifiable +setlocal nrformats=bin,octal,hex +set number +setlocal nonumber +setlocal numberwidth=4 +setlocal omnifunc= +setlocal path= +setlocal nopreserveindent +setlocal nopreviewwindow +setlocal quoteescape=\\ +setlocal readonly +setlocal norelativenumber +setlocal norightleft +setlocal rightleftcmd=search +setlocal noscrollbind +setlocal scrolloff=-1 +setlocal shiftwidth=4 +setlocal noshortname +setlocal showbreak= +setlocal sidescrolloff=-1 +set signcolumn=yes +setlocal signcolumn=yes +setlocal nosmartindent +setlocal nosmoothscroll +setlocal softtabstop=0 +setlocal nospell +setlocal spellcapcheck=[.?!]\\_[\\])'\"\ \ ]\\+ +setlocal spellfile= +setlocal spelllang=en +setlocal spelloptions= +setlocal statusline=%{exists('b:NERDTree')?b:NERDTree.root.path.str():''} +setlocal suffixesadd= +setlocal noswapfile +setlocal synmaxcol=3000 +if &syntax != 'nerdtree' +setlocal syntax=nerdtree +endif +setlocal tabstop=8 +setlocal tagcase= +setlocal tagfunc= +setlocal tags= +setlocal termwinkey= +setlocal termwinscroll=10000 +setlocal termwinsize= +setlocal textwidth=0 +setlocal thesaurus= +setlocal thesaurusfunc= +setlocal noundofile +setlocal undolevels=-123456 +setlocal varsofttabstop= +setlocal vartabstop= +setlocal virtualedit= +setlocal wincolor= +setlocal nowinfixheight +setlocal winfixwidth +setlocal nowrap +setlocal wrapmargin=0 +wincmd w +argglobal +balt static/src/index.tsx +let s:cpo_save=&cpo +set cpo&vim +nmap [c (GitGutterPrevHunk) +nmap \hp (GitGutterPreviewHunk) +nmap \hu (GitGutterUndoHunk) +nmap \hs (GitGutterStageHunk) +xmap \hs (GitGutterStageHunk) +nmap ]c (GitGutterNextHunk) +xmap ac (GitGutterTextObjectOuterVisual) +omap ac (GitGutterTextObjectOuterPending) +xmap ic (GitGutterTextObjectInnerVisual) +omap ic (GitGutterTextObjectInnerPending) +let &cpo=s:cpo_save +unlet s:cpo_save +setlocal keymap= +setlocal noarabic +setlocal autoindent +setlocal backupcopy= +setlocal balloonexpr= +setlocal nobinary +setlocal nobreakindent +setlocal breakindentopt= +setlocal bufhidden= +setlocal buflisted +setlocal buftype= +setlocal nocindent +setlocal cinkeys=0{,0},0),0],:,0#,!^F,o,O,e +setlocal cinoptions= +setlocal cinscopedecls=public,protected,private +setlocal cinwords=if,else,while,do,for,switch +setlocal colorcolumn= +setlocal comments=s1:/*,mb:*,ex:*/,://,b:#,:%,:XCOMM,n:>,fb:- +setlocal commentstring=//\ %s +setlocal complete=.,w,b,u,t,i +setlocal concealcursor= +setlocal conceallevel=0 +setlocal completefunc= +setlocal nocopyindent +setlocal cryptmethod= +setlocal nocursorbind +setlocal nocursorcolumn +setlocal nocursorline +setlocal cursorlineopt=both +setlocal define= +setlocal dictionary= +setlocal nodiff +setlocal equalprg= +setlocal errorformat=%+A\ %#%f\ %#(%l\\,%c):\ %m,%C%m +setlocal noexpandtab +if &filetype != 'typescript' +setlocal filetype=typescript +endif +setlocal fillchars= +setlocal fixendofline +setlocal foldcolumn=0 +setlocal foldenable +setlocal foldexpr=0 +setlocal foldignore=# +setlocal foldlevel=0 +setlocal foldmarker={{{,}}} +setlocal foldmethod=manual +setlocal foldminlines=1 +setlocal foldnestmax=20 +setlocal foldtext=foldtext() +setlocal formatexpr= +setlocal formatoptions=croql +setlocal formatlistpat=^\\s*\\d\\+[\\]:.)}\\t\ ]\\s* +setlocal formatprg= +setlocal grepprg= +setlocal iminsert=0 +setlocal imsearch=-1 +setlocal include= +setlocal includeexpr= +setlocal indentexpr=GetTypescriptIndent() +setlocal indentkeys=0{,0},0),0],:,0#,!^F,o,O,e,0],0) +setlocal noinfercase +setlocal iskeyword=@,48-57,_,192-255,$ +setlocal keywordprg= +setlocal nolinebreak +setlocal nolisp +setlocal lispoptions= +setlocal lispwords= +setlocal nolist +setlocal listchars= +setlocal makeencoding= +setlocal makeprg=tsc\ \ $*\ % +setlocal matchpairs=(:),{:},[:] +setlocal nomodeline +setlocal modifiable +setlocal nrformats=bin,octal,hex +set number +setlocal number +setlocal numberwidth=4 +setlocal omnifunc= +setlocal path= +setlocal nopreserveindent +setlocal nopreviewwindow +setlocal quoteescape=\\ +setlocal noreadonly +setlocal norelativenumber +setlocal norightleft +setlocal rightleftcmd=search +setlocal noscrollbind +setlocal scrolloff=-1 +setlocal shiftwidth=4 +setlocal noshortname +setlocal showbreak= +setlocal sidescrolloff=-1 +set signcolumn=yes +setlocal signcolumn=yes +setlocal nosmartindent +setlocal nosmoothscroll +setlocal softtabstop=0 +setlocal nospell +setlocal spellcapcheck=[.?!]\\_[\\])'\"\ \ ]\\+ +setlocal spellfile= +setlocal spelllang=en +setlocal spelloptions= +setlocal statusline= +setlocal suffixesadd=.ts,.tsx +setlocal swapfile +setlocal synmaxcol=3000 +if &syntax != 'typescript' +setlocal syntax=typescript +endif +setlocal tabstop=8 +setlocal tagcase= +setlocal tagfunc= +setlocal tags= +setlocal termwinkey= +setlocal termwinscroll=10000 +setlocal termwinsize= +setlocal textwidth=0 +setlocal thesaurus= +setlocal thesaurusfunc= +setlocal noundofile +setlocal undolevels=-123456 +setlocal varsofttabstop= +setlocal vartabstop= +setlocal virtualedit= +setlocal wincolor= +setlocal nowinfixheight +setlocal nowinfixwidth +setlocal wrap +setlocal wrapmargin=0 +silent! normal! zE +let &fdl = &fdl +let s:l = 25 - ((24 * winheight(0) + 18) / 37) +if s:l < 1 | let s:l = 1 | endif +keepjumps exe s:l +normal! zt +keepjumps 25 +normal! 0 +wincmd w +argglobal +if bufexists(fnamemodify("utility.ts", ":p")) | buffer utility.ts | else | edit utility.ts | endif +balt static/src/index.tsx +let s:cpo_save=&cpo +set cpo&vim +nmap [c (GitGutterPrevHunk) +nmap \hp (GitGutterPreviewHunk) +nmap \hu (GitGutterUndoHunk) +nmap \hs (GitGutterStageHunk) +xmap \hs (GitGutterStageHunk) +nmap ]c (GitGutterNextHunk) +xmap ac (GitGutterTextObjectOuterVisual) +omap ac (GitGutterTextObjectOuterPending) +xmap ic (GitGutterTextObjectInnerVisual) +omap ic (GitGutterTextObjectInnerPending) +let &cpo=s:cpo_save +unlet s:cpo_save +setlocal keymap= +setlocal noarabic +setlocal autoindent +setlocal backupcopy= +setlocal balloonexpr= +setlocal nobinary +setlocal nobreakindent +setlocal breakindentopt= +setlocal bufhidden= +setlocal buflisted +setlocal buftype= +setlocal nocindent +setlocal cinkeys=0{,0},0),0],:,0#,!^F,o,O,e +setlocal cinoptions= +setlocal cinscopedecls=public,protected,private +setlocal cinwords=if,else,while,do,for,switch +setlocal colorcolumn= +setlocal comments=s1:/*,mb:*,ex:*/,://,b:#,:%,:XCOMM,n:>,fb:- +setlocal commentstring=//\ %s +setlocal complete=.,w,b,u,t,i +setlocal concealcursor= +setlocal conceallevel=0 +setlocal completefunc= +setlocal nocopyindent +setlocal cryptmethod= +setlocal nocursorbind +setlocal nocursorcolumn +setlocal nocursorline +setlocal cursorlineopt=both +setlocal define= +setlocal dictionary= +setlocal nodiff +setlocal equalprg= +setlocal errorformat=%+A\ %#%f\ %#(%l\\,%c):\ %m,%C%m +setlocal noexpandtab +if &filetype != 'typescript' +setlocal filetype=typescript +endif +setlocal fillchars= +setlocal fixendofline +setlocal foldcolumn=0 +setlocal foldenable +setlocal foldexpr=0 +setlocal foldignore=# +setlocal foldlevel=0 +setlocal foldmarker={{{,}}} +setlocal foldmethod=manual +setlocal foldminlines=1 +setlocal foldnestmax=20 +setlocal foldtext=foldtext() +setlocal formatexpr= +setlocal formatoptions=croql +setlocal formatlistpat=^\\s*\\d\\+[\\]:.)}\\t\ ]\\s* +setlocal formatprg= +setlocal grepprg= +setlocal iminsert=0 +setlocal imsearch=-1 +setlocal include= +setlocal includeexpr= +setlocal indentexpr=GetTypescriptIndent() +setlocal indentkeys=0{,0},0),0],:,0#,!^F,o,O,e,0],0) +setlocal noinfercase +setlocal iskeyword=@,48-57,_,192-255,$ +setlocal keywordprg= +setlocal nolinebreak +setlocal nolisp +setlocal lispoptions= +setlocal lispwords= +setlocal nolist +setlocal listchars= +setlocal makeencoding= +setlocal makeprg=tsc\ \ $*\ % +setlocal matchpairs=(:),{:},[:] +setlocal nomodeline +setlocal modifiable +setlocal nrformats=bin,octal,hex +set number +setlocal number +setlocal numberwidth=4 +setlocal omnifunc= +setlocal path= +setlocal nopreserveindent +setlocal nopreviewwindow +setlocal quoteescape=\\ +setlocal noreadonly +setlocal norelativenumber +setlocal norightleft +setlocal rightleftcmd=search +setlocal noscrollbind +setlocal scrolloff=-1 +setlocal shiftwidth=4 +setlocal noshortname +setlocal showbreak= +setlocal sidescrolloff=-1 +set signcolumn=yes +setlocal signcolumn=yes +setlocal nosmartindent +setlocal nosmoothscroll +setlocal softtabstop=0 +setlocal nospell +setlocal spellcapcheck=[.?!]\\_[\\])'\"\ \ ]\\+ +setlocal spellfile= +setlocal spelllang=en +setlocal spelloptions= +setlocal statusline= +setlocal suffixesadd=.ts,.tsx +setlocal swapfile +setlocal synmaxcol=3000 +if &syntax != 'typescript' +setlocal syntax=typescript +endif +setlocal tabstop=8 +setlocal tagcase= +setlocal tagfunc= +setlocal tags= +setlocal termwinkey= +setlocal termwinscroll=10000 +setlocal termwinsize= +setlocal textwidth=0 +setlocal thesaurus= +setlocal thesaurusfunc= +setlocal noundofile +setlocal undolevels=-123456 +setlocal varsofttabstop= +setlocal vartabstop= +setlocal virtualedit= +setlocal wincolor= +setlocal nowinfixheight +setlocal nowinfixwidth +setlocal wrap +setlocal wrapmargin=0 +silent! normal! zE +let &fdl = &fdl +let s:l = 27 - ((26 * winheight(0) + 18) / 37) +if s:l < 1 | let s:l = 1 | endif +keepjumps exe s:l +normal! zt +keepjumps 27 +normal! $ +wincmd w +3wincmd w +exe 'vert 1resize ' . ((&columns * 31 + 137) / 274) +exe 'vert 2resize ' . ((&columns * 120 + 137) / 274) +exe 'vert 3resize ' . ((&columns * 121 + 137) / 274) +tabnext 3 +set stal=1 +if exists('s:wipebuf') && len(win_findbuf(s:wipebuf)) == 0 + silent exe 'bwipe ' . s:wipebuf +endif +unlet! s:wipebuf +set winheight=1 winwidth=20 +set shortmess=filnxtToOS +let &winminheight = s:save_winminheight +let &winminwidth = s:save_winminwidth +let s:sx = expand(":p:r")."x.vim" +if filereadable(s:sx) + exe "source " . fnameescape(s:sx) +endif +let &g:so = s:so_save | let &g:siso = s:siso_save +nohlsearch +doautoall SessionLoadPost +unlet SessionLoad +" vim: set ft=vim : diff --git a/README.md b/README.md index cf7efc4..c87ab4b 100644 --- a/README.md +++ b/README.md @@ -27,6 +27,8 @@ The UDN project aims to provide decentralized and localhost-able infrastructure - [Guidelines](#guidelines) - [The Recommended Way](#the-recommended-way) - [The Manual Way](#the-manual-way) +- [Changes](#changes) + - [1.0.1](#1.0.1) # How it works @@ -144,6 +146,8 @@ By default, the configuration file looks like this: ```JSON { "port": 3000, + "privacy": "", + "imprint": "", "connectedServers": [], "subscribedChannels": [] } @@ -165,6 +169,10 @@ The port and channels are self-explanatory. For servers, you'll need to provide } ``` +Use `\n` to separate lines in the privacy policy. + +For the imprint field, enter a url. + ## Connecting Multiple Servers 1. Add the WebSocket addresses of servers you want to connect to the `connectedServers` array in the configuration file. @@ -233,3 +241,10 @@ export interface WebSocketMessage { 2. Add the properties you want to send 3. Stringify the object via `JSON.stringify()` 4. Send the string via WebSocket + +# Changes +## 1.0.1: +- Add privacy policy for public-facing instances +- Add imprint link +- Remove non-english translations - the UDN web interface is intended for administrators only, maintenance of multiple translations slows down development +- Remove logging - unnecessary but difficult to implement legally diff --git a/bun.lockb b/bun.lockb index 5cfd108..2539fb7 100755 Binary files a/bun.lockb and b/bun.lockb differ diff --git a/config-handler.ts b/config-handler.ts index d1289ec..97da01b 100644 --- a/config-handler.ts +++ b/config-handler.ts @@ -3,6 +3,8 @@ const configPath = "config.json"; export const defaultConfig = { port: 3000, + privacy: "", + imprint: "", connectedServers: [], subscribedChannels: [], }; diff --git a/index.ts b/index.ts index 7d0fdad..c74c882 100755 --- a/index.ts +++ b/index.ts @@ -54,6 +54,10 @@ async function main() { return createFileResponse(DEFAULT_PAGE); case "/stats": return new Response(JSON.stringify(getAllStats())); + case "/privacy": + return new Response(config.privacy); + case "/imprint": + return Response.redirect(config.imprint); default: return createFileResponse(requestPath); } @@ -122,9 +126,6 @@ async function main() { console.clear(); console.log(Colors.bold.bgBlue("UNIVERSAL DECENTRALIZED NETWORK")); - console.log( - Colors.yellow("relevant output is available in the 'logs' file"), - ); writeSeparator(); console.log(new Date().toISOString()); diff --git a/package.json b/package.json index 451a11c..f531cc4 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@vdmdi/udn", - "version": "1.0.0", + "version": "1.0.1", "description": "A websocket-based infrastructure for decentralized networks ", "bin": { "start": "index.ts" @@ -19,7 +19,7 @@ }, "homepage": "https://github.com/marlon-erler/universal-decentralized-network#readme", "dependencies": { - "@types/bun": "^1.1.6", + "@types/bun": "^1.4.3", "@types/ip": "^1.1.3", "colors": "^1.4.0", "express": "^4.19.2", diff --git a/static/dist/index.js b/static/dist/index.js index d469943..14dded6 100644 --- a/static/dist/index.js +++ b/static/dist/index.js @@ -12,7 +12,6 @@ return this._value; } set value(newValue) { - if (this._value == newValue) return; this._value = newValue; this.callSubscriptions(); } @@ -24,6 +23,9 @@ this._bindings.add(fn); fn(this._value); } + subscribeSilent(fn) { + this._bindings.add(fn); + } // stringify toString() { return JSON.stringify(this._value); @@ -32,6 +34,7 @@ var ListState = class extends State { additionHandlers = /* @__PURE__ */ new Set(); removalHandlers = /* @__PURE__ */ new Map(); + genericRemovalHandlers = /* @__PURE__ */ new Set(); // init constructor(initialItems) { super(new Set(initialItems)); @@ -39,6 +42,7 @@ // list add(...items) { items.forEach((item) => { + if (this.value.has(item)) return; this.value.add(item); this.additionHandlers.forEach((handler) => handler(item)); }); @@ -47,8 +51,9 @@ remove(...items) { items.forEach((item) => { this.value.delete(item); + this.genericRemovalHandlers.forEach((handler) => handler(item)); if (!this.removalHandlers.has(item)) return; - this.removalHandlers.get(item)(item); + this.removalHandlers.get(item).forEach((handler) => handler(item)); this.removalHandlers.delete(item); }); this.callSubscriptions(); @@ -62,11 +67,16 @@ [...this.value.values()].forEach(handler); } handleRemoval(item, handler) { - this.removalHandlers.set(item, handler); + if (!this.removalHandlers.has(item)) + this.removalHandlers.set(item, /* @__PURE__ */ new Set()); + this.removalHandlers.get(item).add(handler); + } + handleRemovals(handler) { + this.genericRemovalHandlers.add(handler); } // stringification toString() { - const array = [...this.value]; + const array = [...this.value.values()]; const json = JSON.stringify(array); return json; } @@ -74,7 +84,7 @@ function createProxyState(statesToSubscibe, fn) { const proxyState = new State(fn()); statesToSubscibe.forEach( - (state) => state.subscribe(() => proxyState.value = fn()) + (state) => state.subscribeSilent(() => proxyState.value = fn()) ); return proxyState; } @@ -103,7 +113,7 @@ case "enter": { element.addEventListener("keydown", (e) => { if (e.key != "Enter") return; - value(); + value(e); }); break; } @@ -113,29 +123,19 @@ } break; } + case "keystroke": { + element.addEventListener("keydown", (e) => { + if (e.metaKey == false && e.ctrlKey == false) return; + if (e.key != directiveValue) return; + value(e); + }); + break; + } case "subscribe": { - if (directiveValue == "children") { - element.style.scrollBehavior = "smooth"; - try { - const [listState, toElement] = value; - listState.handleAddition((newItem) => { - const child = toElement(newItem); - listState.handleRemoval( - newItem, - () => child.remove() - ); - element.append(child); - element.scrollTop = element.scrollHeight; - }); - } catch { - throw `error: cannot process subscribe:children directive because ListItemConverter is not defined. Usage: "subscribe:children={[list, converter]}"; you can find a more detailed example in the documentation`; - } - } else { - const state = value; - state.subscribe( - (newValue) => element[directiveValue] = newValue - ); - } + const state = value; + state.subscribe( + (newValue) => element[directiveValue] = newValue + ); break; } case "bind": { @@ -167,6 +167,41 @@ ); break; } + case "children": { + switch (directiveValue) { + case "set": { + const state = value; + state.subscribe((newValue) => { + element.innerHTML = ""; + element.append(...[newValue].flat()); + }); + break; + } + case "append": + case "prepend": { + try { + const [listState, toElement] = value; + listState.handleAddition((newItem) => { + const child = toElement(newItem); + listState.handleRemoval( + newItem, + () => child.remove() + ); + if (directiveValue == "append") { + element.append(child); + } else if (directiveValue == "prepend") { + element.prepend(child); + } + }); + } catch (error) { + console.error(error); + throw `error: cannot process subscribe:children directive. + Usage: "children:append={[list, converter]}"; you can find a more detailed example in the documentation.`; + } + } + } + break; + } default: element.setAttribute(attributename, value); } @@ -213,6 +248,7 @@ // UTILITY METHODS send(messageObject) { if (this.ws == void 0) return false; + if (this.ws.readyState != 1) return false; const messageString = JSON.stringify(messageObject); this.ws.send(messageString); return true; @@ -235,6 +271,7 @@ } else if (data.deletedMailbox) { return this.mailboxDeleteHandler(data.deletedMailbox); } else { + this.send({ uuid: data.uuid, confirmingMessageReceived: true }); this.messageHandler(data); } }); @@ -288,7 +325,7 @@ }; // static/src/translations.tsx - var staticTextEnglish = { + var translations = { mailbox: "Mailbox", requestMailbox: "Request", deleteMailbox: "Delete", @@ -299,72 +336,23 @@ reconnecting: "Reconnecting...", info: "Info", message: "Message", - messages: "Messages", message_placeholder: "Hello, world!", - message_placeholder_generic: "Type a message...", noMessagesReceived: "No messages received", messageLastReceived: "Last received message", - messagesReceived: "Received Messages", - send: "Send", serverInfo: "Server Info", settings: "Settings", subscribeToChannel: "Subscribe to channel", subscribe: "Subscribe", - unsubscribe: "Unubscribe" + unsubscribe: "Unubscribe", + privacyPolicy: "Privacy Policy", + privacyPolicyContent: [ + "Data retention: This server may store messages sent for up to seven days if the recipient has mailboxes enabled in order to receive messages sent to them while they are offline. Mailboxes are deleted after seven days of inactivity, or upon user request. Messages are removed from mailboxes once received. Data stored about messages consists of the channel which the message is sent on, and the message body (content).", + "Processing: This server does not implement any kind of authentication or other means to identify, track, or verify user identity. The administration of this server has no means to track user activity or access data in any way not accessible to other non-administrative users. However, IP addresses are processed in order to uphold connections between client devices and this server (Legal basis: Art. 6(1)(b) GDPR \u2013 provision of the requested communication service)", + "Security: Data sent to this server is broadcasted on channels. Anyone may receive any message if they know the corresponding channel. It is strongly recommended to encrypt messages before sending them to this server (end-to-end encryption).", + "Rights: Pursuant to Art. 11 GDPR, because the administration does not retain records identifying the authors of individual transmissions, individual rights of access or erasure regarding specific messages cannot be fulfilled. Users have the right to lodge a complaint with a competent data protection authority (Art. 77 GDPR)." + ], + imprint: "Imprint" }; - var allTranslations = { - en: staticTextEnglish, - es: { - mailbox: "Buz\xF3n", - requestMailbox: "Solicitar", - deleteMailbox: "Eliminar", - mailboxConnected: "Buz\xF3n activado", - channel: "Canal", - channel_placeholder: "mi-canal", - disconnected: "Sin coneci\xF3n", - reconnecting: "Conectando...", - info: "Info", - message: "Mensaje", - messages: "Mensajes", - message_placeholder: "Hola!", - message_placeholder_generic: "Nuevo mensaje", - noMessagesReceived: "Sin mensajes", - messageLastReceived: "\xDAltimo mensaje", - messagesReceived: "Todos los Mensajes", - send: "Enviar", - serverInfo: "Informaci\xF3n", - settings: "Configuraci\xF3n", - subscribeToChannel: "Suscribirse a un canal", - subscribe: "Suscribirse", - unsubscribe: "Cancelar" - }, - de: { - mailbox: "Briefkasten", - requestMailbox: "Beantragen", - deleteMailbox: "L\xF6schen", - mailboxConnected: "Briefkasten aktiv", - channel: "Kanal", - channel_placeholder: "mein-kanal", - disconnected: "Verbindung getrennt", - reconnecting: "Verbindung wird hergestellt...", - info: "Daten", - message: "Nachricht", - messages: "Nachrichten", - message_placeholder: "Hallo!", - message_placeholder_generic: "Neue Nachricht", - noMessagesReceived: "Keine Nachrichten", - messageLastReceived: "Letzte Nachricht", - messagesReceived: "Empfangene Nachrichten", - send: "Senden", - serverInfo: "Serverdaten", - settings: "Einstellungen", - subscribeToChannel: "Kanal beitreten", - subscribe: "Beitreten", - unsubscribe: "Verlassen" - } - }; - var language = navigator.language.substring(0, 2); - var translations = allTranslations[language]; // static/src/model.tsx var Message = class { @@ -532,41 +520,23 @@ )))); } - // static/src/messageScreen.tsx - var convertMessageToElement = (message) => { - return /* @__PURE__ */ createElement("div", { class: "tile", style: "flex: 0" }, /* @__PURE__ */ createElement("div", null, /* @__PURE__ */ createElement("span", { class: "secondary" }, message.channel), /* @__PURE__ */ createElement("b", null, message.body))); - }; - function MessageScreen() { - return /* @__PURE__ */ createElement("article", { id: "message-screen" }, /* @__PURE__ */ createElement("header", null, translations.messagesReceived), /* @__PURE__ */ createElement("div", null, /* @__PURE__ */ createElement( - "div", - { - class: "flex-column gap", - "subscribe:children": [messages, convertMessageToElement] - } - )), /* @__PURE__ */ createElement("footer", null, /* @__PURE__ */ createElement( - "input", - { - style: "max-width: unset", - placeholder: translations.message_placeholder_generic, - "bind:value": newMessageBody, - "on:enter": sendMessage - } - ), /* @__PURE__ */ createElement( - "button", - { - class: "primary", - "on:click": sendMessage, - "toggle:disabled": isMessageEmpty - }, - /* @__PURE__ */ createElement("span", { class: "icon" }, "send") - ))); + // static/src/privacyScreen.tsx + var specificPolicy = new ListState([]); + fetch("/privacy").then(async (response) => { + (await response.text()).split("\n").forEach((x) => specificPolicy.add(x)); + }); + function paragraph(x) { + return /* @__PURE__ */ createElement("p", null, x); + } + function PrivacyScreen() { + return /* @__PURE__ */ createElement("article", { id: "privacy-screen" }, /* @__PURE__ */ createElement("header", null, translations.privacyPolicy), /* @__PURE__ */ createElement("div", null, ...translations.privacyPolicyContent.map(paragraph), /* @__PURE__ */ createElement("div", { "children:append": [specificPolicy, paragraph] }))); } // static/src/index.tsx document.body.prepend( - /* @__PURE__ */ createElement("menu", null, /* @__PURE__ */ createElement("a", { class: "tab-link", href: "#info-screen", active: true }, /* @__PURE__ */ createElement("span", { class: "icon" }, "info"), translations.info), /* @__PURE__ */ createElement("a", { class: "tab-link", href: "#main-screen" }, /* @__PURE__ */ createElement("span", { class: "icon" }, "settings"), translations.settings), /* @__PURE__ */ createElement("a", { class: "tab-link", href: "#message-screen" }, /* @__PURE__ */ createElement("span", { class: "icon" }, "chat"), translations.messages)) + /* @__PURE__ */ createElement("menu", null, /* @__PURE__ */ createElement("a", { class: "tab-link", href: "#info-screen", active: true }, /* @__PURE__ */ createElement("span", { class: "icon" }, "info"), translations.info), /* @__PURE__ */ createElement("a", { class: "tab-link", href: "#main-screen" }, /* @__PURE__ */ createElement("span", { class: "icon" }, "settings"), translations.settings), /* @__PURE__ */ createElement("a", { class: "tab-link", href: "#privacy-screen" }, /* @__PURE__ */ createElement("span", { class: "icon" }, "privacy_tip"), translations.privacyPolicy), /* @__PURE__ */ createElement("a", { class: "tab-link", href: "/imprint" }, /* @__PURE__ */ createElement("span", { class: "icon" }, "attribution"), translations.imprint)) ); - document.querySelector("main").append(InfoScreen(), MainScreen(), MessageScreen()); + document.querySelector("main").append(InfoScreen(), MainScreen(), PrivacyScreen()); document.body.append( /* @__PURE__ */ createElement("div", { class: "modal", "toggle:open": isDisconnected }, /* @__PURE__ */ createElement("div", null, /* @__PURE__ */ createElement("main", null, /* @__PURE__ */ createElement( "div", diff --git a/static/node_modules/.bin/uuid b/static/node_modules/.bin/uuid index 588f70e..a0e681c 120000 --- a/static/node_modules/.bin/uuid +++ b/static/node_modules/.bin/uuid @@ -1 +1 @@ -../uuid/dist/bin/uuid \ No newline at end of file +../uuid/dist-node/bin/uuid \ No newline at end of file diff --git a/static/node_modules/.package-lock.json b/static/node_modules/.package-lock.json index 561c312..3ce049e 100644 --- a/static/node_modules/.package-lock.json +++ b/static/node_modules/.package-lock.json @@ -3,34 +3,37 @@ "lockfileVersion": 3, "requires": true, "packages": { - "node_modules/@esbuild/darwin-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.23.0.tgz", - "integrity": "sha512-IMQ6eme4AfznElesHUPDZ+teuGwoRmVuuixu7sv92ZkdQcPbsNHzutd+rAfaBKo8YK3IrBEi9SLLKWJdEvJniQ==", + "node_modules/@esbuild/linux-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz", + "integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==", "cpu": [ - "x64" + "arm64" ], + "license": "MIT", "optional": true, "os": [ - "darwin" + "linux" ], "engines": { "node": ">=18" } }, "node_modules/bloatless-react": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/bloatless-react/-/bloatless-react-1.1.3.tgz", - "integrity": "sha512-fSJ8XLqn4K0sLR4yMOLJL+re0s/LjynGPJbZsXxBWMM6dpP2lF6lE94xppLfCdJkW4eBPJKCdqQJXWFgzsN8TA==", + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/bloatless-react/-/bloatless-react-1.4.0.tgz", + "integrity": "sha512-jtrhf8MJQ0AkN4/nnXSlhRjaWZZZawJfkxA8PX3NKe5TKhILsNhHKeYfkJpCytNG9YtfrDiYtiXUNQHqpp+oBQ==", + "license": "SEE LICENSE IN LICENSE", "dependencies": { - "uuid": "^10.0.0" + "uuid": "^13.0.0" } }, "node_modules/esbuild": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.23.0.tgz", - "integrity": "sha512-1lvV17H2bMYda/WaFb2jLPeHU3zml2k4/yagNMG8Q/YtfMjCwEUZa2eXXMgZTVSL5q1n4H7sQ0X6CdJDqqeCFA==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz", + "integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==", "hasInstallScript": true, + "license": "MIT", "bin": { "esbuild": "bin/esbuild" }, @@ -38,42 +41,51 @@ "node": ">=18" }, "optionalDependencies": { - "@esbuild/aix-ppc64": "0.23.0", - "@esbuild/android-arm": "0.23.0", - "@esbuild/android-arm64": "0.23.0", - "@esbuild/android-x64": "0.23.0", - "@esbuild/darwin-arm64": "0.23.0", - "@esbuild/darwin-x64": "0.23.0", - "@esbuild/freebsd-arm64": "0.23.0", - "@esbuild/freebsd-x64": "0.23.0", - "@esbuild/linux-arm": "0.23.0", - "@esbuild/linux-arm64": "0.23.0", - "@esbuild/linux-ia32": "0.23.0", - "@esbuild/linux-loong64": "0.23.0", - "@esbuild/linux-mips64el": "0.23.0", - "@esbuild/linux-ppc64": "0.23.0", - "@esbuild/linux-riscv64": "0.23.0", - "@esbuild/linux-s390x": "0.23.0", - "@esbuild/linux-x64": "0.23.0", - "@esbuild/netbsd-x64": "0.23.0", - "@esbuild/openbsd-arm64": "0.23.0", - "@esbuild/openbsd-x64": "0.23.0", - "@esbuild/sunos-x64": "0.23.0", - "@esbuild/win32-arm64": "0.23.0", - "@esbuild/win32-ia32": "0.23.0", - "@esbuild/win32-x64": "0.23.0" + "@esbuild/aix-ppc64": "0.28.2", + "@esbuild/android-arm": "0.28.2", + "@esbuild/android-arm64": "0.28.2", + "@esbuild/android-x64": "0.28.2", + "@esbuild/darwin-arm64": "0.28.2", + "@esbuild/darwin-x64": "0.28.2", + "@esbuild/freebsd-arm64": "0.28.2", + "@esbuild/freebsd-x64": "0.28.2", + "@esbuild/linux-arm": "0.28.2", + "@esbuild/linux-arm64": "0.28.2", + "@esbuild/linux-ia32": "0.28.2", + "@esbuild/linux-loong64": "0.28.2", + "@esbuild/linux-mips64el": "0.28.2", + "@esbuild/linux-ppc64": "0.28.2", + "@esbuild/linux-riscv64": "0.28.2", + "@esbuild/linux-s390x": "0.28.2", + "@esbuild/linux-x64": "0.28.2", + "@esbuild/netbsd-arm64": "0.28.2", + "@esbuild/netbsd-x64": "0.28.2", + "@esbuild/openbsd-arm64": "0.28.2", + "@esbuild/openbsd-x64": "0.28.2", + "@esbuild/openharmony-arm64": "0.28.2", + "@esbuild/sunos-x64": "0.28.2", + "@esbuild/win32-arm64": "0.28.2", + "@esbuild/win32-ia32": "0.28.2", + "@esbuild/win32-x64": "0.28.2" } }, + "node_modules/udn-frontend": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/udn-frontend/-/udn-frontend-1.0.9.tgz", + "integrity": "sha512-6wDnGEFQ0Jan33+3yxIEq2ukeuuZjtmvQylHpAL/VDa2ioCEkzTPMvskGdClXBpEh0scPUQwU5QWL6q33U4rsA==", + "license": "SEE LICENSE IN LICENSE" + }, "node_modules/uuid": { - "version": "10.0.0", - "resolved": "https://registry.npmjs.org/uuid/-/uuid-10.0.0.tgz", - "integrity": "sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==", + "version": "13.0.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-13.0.2.tgz", + "integrity": "sha512-vzi9uRZ926x4XV73S/4qQaTwPXM2JBj6/6lI/byHH1jOpCzb0zDbfytgA9LcN/hzb2l7WQSQnxITOVx5un/wGw==", "funding": [ "https://github.com/sponsors/broofa", "https://github.com/sponsors/ctavan" ], + "license": "MIT", "bin": { - "uuid": "dist/bin/uuid" + "uuid": "dist-node/bin/uuid" } } } diff --git a/static/node_modules/@esbuild/darwin-x64/README.md b/static/node_modules/@esbuild/darwin-x64/README.md deleted file mode 100644 index a2fd0cb..0000000 --- a/static/node_modules/@esbuild/darwin-x64/README.md +++ /dev/null @@ -1,3 +0,0 @@ -# esbuild - -This is the macOS 64-bit binary for esbuild, a JavaScript bundler and minifier. See https://github.com/evanw/esbuild for details. diff --git a/static/node_modules/@esbuild/darwin-x64/bin/esbuild b/static/node_modules/@esbuild/darwin-x64/bin/esbuild deleted file mode 100755 index 55aebdf..0000000 Binary files a/static/node_modules/@esbuild/darwin-x64/bin/esbuild and /dev/null differ diff --git a/static/node_modules/@esbuild/darwin-x64/package.json b/static/node_modules/@esbuild/darwin-x64/package.json deleted file mode 100644 index f67a6bc..0000000 --- a/static/node_modules/@esbuild/darwin-x64/package.json +++ /dev/null @@ -1,20 +0,0 @@ -{ - "name": "@esbuild/darwin-x64", - "version": "0.23.0", - "description": "The macOS 64-bit binary for esbuild, a JavaScript bundler.", - "repository": { - "type": "git", - "url": "git+https://github.com/evanw/esbuild.git" - }, - "license": "MIT", - "preferUnplugged": true, - "engines": { - "node": ">=18" - }, - "os": [ - "darwin" - ], - "cpu": [ - "x64" - ] -} diff --git a/static/node_modules/bloatless-react/README.md b/static/node_modules/bloatless-react/README.md index 10e43bb..4ad6c63 100644 --- a/static/node_modules/bloatless-react/README.md +++ b/static/node_modules/bloatless-react/README.md @@ -44,12 +44,21 @@ const age = new React.State(69); //will be State // Get value console.log(name.value); +// John Doe // Subscribe age.subscribe(newAge => console.log(`Age changed to ${newAge}`)); +// Age changed to 69 + +React.bulkSubscribe([name, age], () => console.log(`${name.value} is ${age.value} years old`)) // Set value -name.value = "Jeff"; +age.value = 70; +// Age changed to 70 +// John Doe is 70 years old + +name.value = "Josh" +// Josh is 70 years old ``` ## Proxy States @@ -61,43 +70,85 @@ A Proxy State is a State based on multiple other States. This reduces code and c import * as React from 'bloatless-react'; // Create States -const name = new React.State("John Doe"); // will be State -const age = new React.State(69); //will be State +const name = new React.State("John Doe"); +const age = new React.State(69); // Proxy State const summary = React.createProxyState([name, age], () => `${name.value} is ${age.value} years old.`) summary.subscribe(console.log); +//John Doe is 69 years old. ``` ## ListStates -A `ListState` is a State whose value is a `Set`. A ListState allows specific subscriptions to detect when items get added and removed. This allows dynamic lists to run efficiently. +A `ListState` is a State whose value is a `Set`. A ListState allows specific subscriptions to detect when items get added and removed. ```TypeScript -// Import -import * as React from 'bloatless-react'; +import * as React from "bloatless-react"; -// Define Item type -class Item implements React.Identifiable { - id = React.UUID(); - constructor(public text: string) {} -} +const listState = new React.ListState([1, 2]); -// Create ListState -const listState = new React.ListState(); +console.log(listState.value); +// Set [ 1, 2 ] -// Handle addition and removal -listState.handleAddition((newItem) => { - console.log(`${newItem.text} was added`); - listState.handleRemoval(newItem, () => console.log(`${newItem.text} was removed`)); +listState.handleRemovals((item) => console.log(item + " removed")); +listState.handleAddition((newItem: number) => { + console.log("+", newItem); + + listState.handleRemoval(newItem, () => { + console.log("-", newItem); + }); }); +// + 1 +// + 2 -// Add item -const newItem = new Item("hello, world!"); -listState.add(newItem); +listState.add(3); +// + 3 -// Remove item -listState.remove(newItem); +listState.remove(1); +// - 1 + +listState.clear(); +// - 2 +// - 3 + +``` + +## MapStates + +A `MapState` is a State whose value is a `Map`. A ListState allows specific subscriptions to detect when items get added and removed. + +```TypeScript +import * as React from "bloatless-react"; + +const mapState = new React.MapState([ + ["a", 1], + ["b", 2], +]) + +console.log(mapState.value); +// Map { a → 1, b → 2 } + +mapState.handleRemovals((item) => console.log(item + " removed")); +mapState.handleAddition((newItem: number) => { + console.log("+", newItem) + + mapState.handleRemoval(newItem, () => { + console.log("-", newItem) + }) +}); +// + 1 +// + 2 + +mapState.set("c", 3); +// + 3 + +mapState.remove("a"); +// - 1 + +mapState.clear(); +// - 2 +// - 3 ``` ## Persistence @@ -105,11 +156,23 @@ listState.remove(newItem); States can persist through reloads via LocalStorage. To implement this, modify your code like this: ```diff +normal State -const myState = new React.State("hello"); +const myState = React.restoreState("my-state", "hello"); --const myListState = new React.ListState(); -+const myListState = React.restoreListState("my-list-state"); +MapState +-const myMapState = new React.MapState(); ++const myMapState = React.restoreMapState("my-map-state"); +OR +-const myMapState = new React.MapState([["a", 1], ["b", 2]]); ++const myMapState = React.restoreMapState("my-map-state", [["a", 1], ["b", 2]]); + +ListState +-const myListState = new React.ListState(); ++const myListState = React.restoreListState("my-list-state"); +OR +-const myListState = new React.ListState([1, 2]); ++const myListState = React.restoreListState("my-list-state", [1, 2]); ``` # UI @@ -125,6 +188,7 @@ The `on:` directive adds an EventListener. This directive also supports t ```TypeScript +
...
// triggers when pressing Command/Ctrl+s ``` ## Changing Properties @@ -167,49 +231,70 @@ const name = new React.State("John Doe"); ## Dynamically Creating and Removing Child Elements -The `subscribe:children` directive subscribes to a ListState and adds/removes child elements accordingly. +The **children:set** subscribes to a `State` or `State` and replaces the element's contents with the State's value. ```TypeScript -import * as React from 'bloatless-react'; +let count = 0; +const childElement = new React.State(
0
); -// Define Item -class Item implements React.Identifiable { - id = React.UUID(); - constructor(public text: string) {} +function change() { + count++; + childElement.value =
{count}
; } -// This ListItemConverter creates an HTML element based on an Item -const convertItem: React.ListItemConverter = (item) => { +document.body.append( +
+ +
+
+); +``` + +The **children:append** and **children:prepend** directives subscribe to a `ListState` or `MapState` and sync the element's contents accordingly. + +The StateItemConverter turns an item of the State into an HTMLElement. + +```TypeScript +import * as React from "bloatless-react"; + +// Model +class MyDataModel { + items = new React.ListState(); + newItemName = new React.State(""); + + addItem = () => { + console.log(this); + this.items.add(this.newItemName.value); + }; + removeItem = (item: string) => { + this.items.remove(item); + }; +} + +const model = new MyDataModel(); + +// Item -> Element +const convertItem: React.StateItemConverter = (item: string) => { function remove() { - // you should keep track of your data in a separate model - // keep your removeListItem() method there - myDataModel.removeListItem(item); + model.removeItem(item); } return ( - {item.text} + {item} ); }; -// Create ListState -const listState = new React.ListState(); - -// Prepare adding items -const newItemName = new React.State(""); - -function addItem() { - const newItem = new Item(newItemName.value); - listState.add(newItem); -} - // Build UI document.body.append(
- - -
+ + +
); ``` @@ -271,4 +356,79 @@ Other changes: ## 1.2.5 -- Instead of using `scrollIntoView()`, `subscribe:children` now scrolls to the bottom \ No newline at end of file +- Instead of using `scrollIntoView()`, `subscribe:children` now scrolls to the bottom + +## 1.3.0 + +**BREAKING CHANGES** + +- Replace `set:children` with `children:append` + +Other changes + +- Add `children:` directive +- Improve documentation + +## 1.3.1 + +- Allow arrays to be passed to `children:set` + +## 1.3.2 + +- Allow initial value on `restoreListState()` +- Add `MapState` and `restoreMapState()` + +## 1.3.3 + +- Rename `ListItemConverter` to `StateItemConverter` +- Improve documentation + +## 1.3.4 + +- Remove old item from `MapState` when calling `MapState.set()` for an existing key + +## 1.3.5 + +- Fix bug where `MapState.clear()` would not trigger removal handlers + +## 1.3.6 + +- Add `State.subscribeSilent()` +- Add `bulkSubscribe()` + +## 1.3.7 + +- `bulkSubscribe()` does not fire the callback when set up + +## 1.3.8 + +- Allow multiple handlers for `MapState` and `ListState` + +## 1.3.9 + +- Improve error handling +- Fix error where the `children:` directive would attempt to set attributes + +## 1.3.10 + +- Improve error handling + +## 1.3.11 + +- Add `metakey:` directive +- Pass event to `on:enter` call + +## 1.3.12 +- Replace `metakey:` with `keystroke:` directive to support control key additionally + +## 1.3.13 +- trigger state subscriptions even when value is unchanged + +## 1.3.14 +- fix bug where proxy states would trigger subscriptions upon creation$a + +## 1.3.15 +- do not re-add values to `ListState` if already present + +## 1.4.0 +- Add `handleRemovals` method diff --git a/static/node_modules/bloatless-react/dist/index.js b/static/node_modules/bloatless-react/dist/index.js deleted file mode 100644 index 6d5b158..0000000 --- a/static/node_modules/bloatless-react/dist/index.js +++ /dev/null @@ -1 +0,0 @@ -(()=>{var a=class{value;constructor(){this.value=""}toString(){return this.value}};function l(t){return t instanceof r?t.value:t}function o(t){return t instanceof r?t:new r(t)}var r=class{_value;_bindings=new Set;constructor(e){this._value=e}get value(){return this._value}set value(e){this._value!=e&&(this._value=e,this.callSubscriptions())}callSubscriptions(){this._bindings.forEach(e=>e(this._value))}subscribe(e){this._bindings.add(e)}},s=class extends r{additionHandlers=new Set;removalHandlers=new Map;constructor(){super(new Set)}add(...e){e.forEach(i=>{this.value.add(i),this.additionHandlers.forEach(n=>n(i))})}delete(...e){e.forEach(i=>{this.value.delete(i);let n=i.uuid;this.removalHandlers.has(n)&&(this.removalHandlers.get(n)(i),this.removalHandlers.delete(n))})}handleAddition(e){this.additionHandlers.add(e)}handleRemoval(e,i){this.removalHandlers.set(e.uuid,i)}};function d(t,e,i,n="input"){i.subscribe(u=>{t[e]=i.value}),t.addEventListener(n,()=>{i.value=t[e]})}})(); diff --git a/static/node_modules/bloatless-react/index.ts b/static/node_modules/bloatless-react/index.ts index d80f107..e49bfeb 100755 --- a/static/node_modules/bloatless-react/index.ts +++ b/static/node_modules/bloatless-react/index.ts @@ -24,7 +24,7 @@ export type RemovalSubscription = (removedItem: T) => void; export class State { private _value: T; - private _bindings = new Set>(); + _bindings = new Set>(); // init constructor(initialValue: T) { @@ -37,7 +37,6 @@ export class State { } set value(newValue: T) { - if (this._value == newValue) return; this._value = newValue; this.callSubscriptions(); } @@ -52,6 +51,10 @@ export class State { fn(this._value); } + subscribeSilent(fn: (newValue: T) => void): void { + this._bindings.add(fn); + } + // stringify toString(): string { return JSON.stringify(this._value); @@ -60,7 +63,8 @@ export class State { export class ListState extends State> { private additionHandlers = new Set>(); - private removalHandlers = new Map>(); + private removalHandlers = new Map>>(); + private genericRemovalHandlers = new Set>(); // init constructor(initialItems?: T[]) { @@ -70,6 +74,7 @@ export class ListState extends State> { // list add(...items: T[]): void { items.forEach((item) => { + if (this.value.has(item)) return; this.value.add(item); this.additionHandlers.forEach((handler) => handler(item)); }); @@ -80,8 +85,9 @@ export class ListState extends State> { items.forEach((item) => { this.value.delete(item); + this.genericRemovalHandlers.forEach(handler => handler(item)); if (!this.removalHandlers.has(item)) return; - this.removalHandlers.get(item)!(item); + this.removalHandlers.get(item)!.forEach((handler) => handler(item)); this.removalHandlers.delete(item); }); this.callSubscriptions(); @@ -98,17 +104,82 @@ export class ListState extends State> { } handleRemoval(item: T, handler: RemovalSubscription): void { - this.removalHandlers.set(item, handler); + if (!this.removalHandlers.has(item)) + this.removalHandlers.set(item, new Set()); + this.removalHandlers.get(item)!.add(handler); + } + + handleRemovals(handler: RemovalSubscription): void { + this.genericRemovalHandlers.add(handler); } // stringification toString(): string { - const array = [...this.value]; + const array = [...this.value.values()]; const json = JSON.stringify(array); return json; } } +export class MapState extends State> { + private additionHandlers = new Set>(); + private removalHandlers = new Map>>(); + private genericRemovalHandlers = new Set>(); + + // init + constructor(initialItems?: [string, T][]) { + super(new Map(initialItems)); + } + + // list + set(key: string, item: T): void { + this.remove(key); + this.value.set(key, item); + this.additionHandlers.forEach((handler) => handler(item)); + this.callSubscriptions(); + } + + remove(key: string): void { + const item = this.value.get(key); + if (!item) return; + + this.value.delete(key); + this.callSubscriptions(); + + this.genericRemovalHandlers.forEach(handler => handler(item)); + if (!this.removalHandlers.has(item)) return; + this.removalHandlers.get(item)!.forEach((handler) => handler(item)); + this.removalHandlers.delete(item); + } + + clear() { + [...this.value.keys()].forEach((key) => this.remove(key)); + } + + // handlers + handleAddition(handler: AdditionSubscription): void { + this.additionHandlers.add(handler); + [...this.value.values()].forEach(handler); + } + + handleRemoval(item: T, handler: RemovalSubscription): void { + if (!this.removalHandlers.has(item)) + this.removalHandlers.set(item, new Set()); + this.removalHandlers.get(item)!.add(handler); + } + + handleRemovals(handler: RemovalSubscription): void { + this.genericRemovalHandlers.add(handler); + } + + // stringification + toString(): string { + const array = [...this.value.entries()]; + const json = JSON.stringify(array); + return json; + } +} + // UTILITY export function createProxyState( statesToSubscibe: State[], @@ -116,15 +187,22 @@ export function createProxyState( ): State { const proxyState = new State(fn()); statesToSubscibe.forEach((state) => - state.subscribe(() => (proxyState.value = fn())) + state.subscribeSilent(() => (proxyState.value = fn())) ); return proxyState; } +export function bulkSubscribe( + statesToSubscibe: State[], + fn: () => void +): void { + statesToSubscibe.forEach((state) => state.subscribeSilent(fn)); +} + function persistState(localStorageKey: string, state: State) { state.subscribe(() => { - const stringifiedValue = state.toString(); - localStorage.setItem(localStorageKey, stringifiedValue); + const stringifiedValue = state.toString(); + localStorage.setItem(localStorageKey, stringifiedValue); }); } @@ -133,8 +211,8 @@ export function restoreState( initialStateValue: T ): State { const storedString = - localStorage.getItem(localStorageKey) ?? - JSON.stringify(initialStateValue); + localStorage.getItem(localStorageKey) ?? + JSON.stringify(initialStateValue); const convertedValue = JSON.parse(storedString); const state = new State(convertedValue); @@ -144,16 +222,15 @@ export function restoreState( } export function restoreListState( - localStorageKey: string + localStorageKey: string, + initialItems: any[] = [] ): ListState { const storedString = localStorage.getItem(localStorageKey) ?? ""; - let initialItems: any[] = []; - try { - const array = JSON.parse(storedString); - if (!Array.isArray(array)) throw ""; - initialItems = array; + const array = JSON.parse(storedString); + if (!Array.isArray(array)) throw ""; + initialItems = array; } catch {} const state = new ListState(initialItems); @@ -162,13 +239,29 @@ export function restoreListState( return state; } -export type ListItemConverter = ( - item: T -) => HTMLElement; +export function restoreMapState( + localStorageKey: string, + initialItems: [string, any][] = [] +): MapState { + const storedString = localStorage.getItem(localStorageKey) ?? ""; + + try { + const array = JSON.parse(storedString); + if (!Array.isArray(array)) throw ""; + initialItems = array; + } catch {} + + const state = new MapState(initialItems); + persistState(localStorageKey, state); + + return state; +} + +export type StateItemConverter = (item: T) => HTMLElement; /* JSX -*/ + */ export function createElement( tagName: keyof HTMLElementTagNameMap, @@ -178,87 +271,113 @@ export function createElement( const element = document.createElement(tagName); if (attributes != null) - Object.entries(attributes).forEach((entry) => { - const [attributename, value] = entry; - const [directiveKey, directiveValue] = attributename.split(":"); + Object.entries(attributes).forEach((entry) => { + const [attributename, value] = entry; + const [directiveKey, directiveValue] = attributename.split(":"); - switch (directiveKey) { - case "on": { - switch (directiveValue) { - case "enter": { - element.addEventListener("keydown", (e) => { - if ((e as KeyboardEvent).key != "Enter") return; - value(); - }); - break; - } - default: { - element.addEventListener(directiveValue, value); - } - } - break; - } - case "subscribe": { - if (directiveValue == "children") { - element.style.scrollBehavior = "smooth"; - try { - const [listState, toElement] = value as [ - listState: ListState, - ListItemConverter - ]; + switch (directiveKey) { + case "on": { + switch (directiveValue) { + case "enter": { + element.addEventListener("keydown", (e: KeyboardEvent) => { + if (e.key != "Enter") return; + value(e); + }); + break; + } + default: { + element.addEventListener(directiveValue, value); + } + } + break; + } + case "keystroke": { + element.addEventListener("keydown", (e: KeyboardEvent) => { + if (e.metaKey == false && e.ctrlKey == false) return; + if (e.key != directiveValue) return; + value(e); + }) + break; + } + case "subscribe": { + const state = value as State; + state.subscribe( + (newValue) => (element[directiveValue] = newValue) + ); - listState.handleAddition((newItem) => { - const child = toElement(newItem); - listState.handleRemoval(newItem, () => - child.remove() - ); - element.append(child); - element.scrollTop = element.scrollHeight; - }); - } catch { - throw `error: cannot process subscribe:children directive because ListItemConverter is not defined. Usage: "subscribe:children={[list, converter]}"; you can find a more detailed example in the documentation`; - } - } else { - const state = value as State; - state.subscribe( - (newValue) => (element[directiveValue] = newValue) - ); - } - break; - } - case "bind": { - const state = value as State; - state.subscribe( - (newValue) => (element[directiveValue] = newValue) - ); - element.addEventListener( - "input", - () => (state.value = (element as any)[directiveValue]) - ); - break; - } - case "toggle": { - if (value.subscribe) { - const state = value as State; - state.subscribe((newValue) => - element.toggleAttribute(directiveValue, newValue) - ); - } else { - element.toggleAttribute(directiveValue, value); - } - break; - } - case "set": { - const state = value as State; - state.subscribe((newValue) => - element.setAttribute(directiveValue, newValue) - ); - break; - } - default: - element.setAttribute(attributename, value); - } - }); + break; + } + case "bind": { + const state = value as State; + state.subscribe( + (newValue) => (element[directiveValue] = newValue) + ); + element.addEventListener( + "input", + () => (state.value = (element as any)[directiveValue]) + ); + break; + } + case "toggle": { + if (value.subscribe) { + const state = value as State; + state.subscribe((newValue) => + element.toggleAttribute(directiveValue, newValue) + ); + } else { + element.toggleAttribute(directiveValue, value); + } + break; + } + case "set": { + const state = value as State; + state.subscribe((newValue) => + element.setAttribute(directiveValue, newValue) + ); + break; + } + case "children": { + switch (directiveValue) { + case "set": { + const state = value as State; + state.subscribe((newValue) => { + element.innerHTML = ""; + element.append(...[newValue].flat()); + }); + break; + } + case "append": + case "prepend": { + try { + const [listState, toElement] = value as [ + listState: ListState, + StateItemConverter + ]; + + listState.handleAddition((newItem) => { + const child = toElement(newItem); + listState.handleRemoval(newItem, () => + child.remove() + ); + + if (directiveValue == "append") { + element.append(child); + } else if (directiveValue == "prepend") { + element.prepend(child); + } + }); + } catch (error) { + console.error(error); + throw `error: cannot process subscribe:children directive. \n Usage: "children:append={[list, converter]}"; you can find a more detailed example in the documentation.`; + } + } + } + break; + } + default: + element.setAttribute(attributename, value); + } + }); children.filter((x) => x).forEach((child) => element.append(child)); diff --git a/static/node_modules/bloatless-react/package.json b/static/node_modules/bloatless-react/package.json index 5b86dd5..7f70c36 100644 --- a/static/node_modules/bloatless-react/package.json +++ b/static/node_modules/bloatless-react/package.json @@ -1,6 +1,6 @@ { "name": "bloatless-react", - "version": "1.2.6", + "version": "1.4.0", "description": "very minimal and flexible react alternative", "repository": { "type": "git", @@ -9,6 +9,6 @@ "author": "marlon-erler", "license": "SEE LICENSE IN LICENSE", "dependencies": { - "uuid": "^10.0.0" + "uuid": "^13.0.0" } } diff --git a/static/node_modules/esbuild/bin/esbuild b/static/node_modules/esbuild/bin/esbuild index 55aebdf..3282e10 100755 Binary files a/static/node_modules/esbuild/bin/esbuild and b/static/node_modules/esbuild/bin/esbuild differ diff --git a/static/node_modules/esbuild/install.js b/static/node_modules/esbuild/install.js index 86b6c43..ee09eff 100644 --- a/static/node_modules/esbuild/install.js +++ b/static/node_modules/esbuild/install.js @@ -49,6 +49,7 @@ var knownUnixlikePackages = { "linux s390x BE": "@esbuild/linux-s390x", "linux x64 LE": "@esbuild/linux-x64", "linux loong64 LE": "@esbuild/linux-loong64", + "netbsd arm64 LE": "@esbuild/netbsd-arm64", "netbsd x64 LE": "@esbuild/netbsd-x64", "openbsd arm64 LE": "@esbuild/openbsd-arm64", "openbsd x64 LE": "@esbuild/openbsd-x64", @@ -56,7 +57,8 @@ var knownUnixlikePackages = { }; var knownWebAssemblyFallbackPackages = { "android arm LE": "@esbuild/android-arm", - "android x64 LE": "@esbuild/android-x64" + "android x64 LE": "@esbuild/android-x64", + "openharmony arm64 LE": "@esbuild/openharmony-arm64" }; function pkgAndSubpathForCurrentPlatform() { let pkg; @@ -89,8 +91,9 @@ var os2 = require("os"); var path2 = require("path"); var zlib = require("zlib"); var https = require("https"); +var crypto = require("crypto"); var child_process = require("child_process"); -var versionFromPackageJSON = require(path2.join(__dirname, "package.json")).version; +var packageJSON = require(path2.join(__dirname, "package.json")); var toPath = path2.join(__dirname, "bin", "esbuild"); var isToPathJS = true; function validateBinaryVersion(...command) { @@ -130,8 +133,8 @@ which means the "esbuild" binary executable can't be run. You can either: } throw err; } - if (stdout !== versionFromPackageJSON) { - throw new Error(`Expected ${JSON.stringify(versionFromPackageJSON)} but got ${JSON.stringify(stdout)}`); + if (stdout !== packageJSON.version) { + throw new Error(`Expected ${JSON.stringify(packageJSON.version)} but got ${JSON.stringify(stdout)}`); } } function isYarn() { @@ -167,7 +170,7 @@ function extractFileFromTarGzip(buffer, subpath) { let name = str(offset, 100); let size = parseInt(str(offset + 124, 12), 8); offset += 512; - if (!isNaN(size)) { + if (!isNaN(size) && size >= 0) { if (name === subpath) return buffer.subarray(offset, offset + size); offset += size + 511 & ~511; } @@ -182,10 +185,11 @@ function installUsingNPM(pkg, subpath, binPath) { try { fs2.writeFileSync(path2.join(installDir, "package.json"), "{}"); child_process.execSync( - `npm install --loglevel=error --prefer-offline --no-audit --progress=false ${pkg}@${versionFromPackageJSON}`, + `npm install --loglevel=error --prefer-offline --no-audit --progress=false ${pkg}@${packageJSON.version}`, { cwd: installDir, stdio: "pipe", env } ); const installedBinPath = path2.join(installDir, "node_modules", pkg, subpath); + binaryIntegrityCheck(pkg, subpath, fs2.readFileSync(installedBinPath)); fs2.renameSync(installedBinPath, binPath); } finally { try { @@ -218,8 +222,8 @@ require('child_process').execFileSync(${pathString}, process.argv.slice(2), { st fs2.writeFileSync(libMain, `var ESBUILD_BINARY_PATH = ${pathString}; ${code}`); } -function maybeOptimizePackage(binPath) { - if (os2.platform() !== "win32" && !isYarn()) { +function maybeOptimizePackage(binPath, isWASM) { + if (os2.platform() !== "win32" && !isYarn() && !isWASM) { const tempPath = path2.join(__dirname, "bin-esbuild"); try { fs2.linkSync(binPath, tempPath); @@ -230,11 +234,20 @@ function maybeOptimizePackage(binPath) { } } } +function binaryIntegrityCheck(pkg, subpath, bytes) { + const hash = crypto.createHash("sha256").update(bytes).digest("hex"); + const key = `${pkg}/${subpath}`; + const expected = packageJSON["esbuild.binaryHashes"][key]; + if (!expected) throw new Error(`Missing hash for "${key}"`); + if (hash !== expected) throw new Error(`"${hash.slice(0, 8)}..." doesn't match "${expected.slice(0, 8)}..." for "${pkg}"`); +} async function downloadDirectlyFromNPM(pkg, subpath, binPath) { - const url = `https://registry.npmjs.org/${pkg}/-/${pkg.replace("@esbuild/", "")}-${versionFromPackageJSON}.tgz`; + const url = `https://registry.npmjs.org/${pkg}/-/${pkg.replace("@esbuild/", "")}-${packageJSON.version}.tgz`; console.error(`[esbuild] Trying to download ${JSON.stringify(url)}`); try { - fs2.writeFileSync(binPath, extractFileFromTarGzip(await fetch(url), subpath)); + const bytes = extractFileFromTarGzip(await fetch(url), subpath); + binaryIntegrityCheck(pkg, subpath, bytes); + fs2.writeFileSync(binPath, bytes); fs2.chmodSync(binPath, 493); } catch (e) { console.error(`[esbuild] Failed to download ${JSON.stringify(url)}: ${e && e.message || e}`); @@ -250,7 +263,7 @@ async function checkAndPreparePackage() { return; } } - const { pkg, subpath } = pkgAndSubpathForCurrentPlatform(); + const { pkg, subpath, isWASM } = pkgAndSubpathForCurrentPlatform(); let binPath; try { binPath = require.resolve(`${pkg}/${subpath}`); @@ -262,6 +275,7 @@ package.json feature is used by esbuild to install the correct binary executable for your current platform. This install script will now attempt to work around this. If that fails, you need to remove the "--no-optional" flag to use esbuild. `); + if (isWASM) throw new Error(`Failed to install package "${pkg}"`); binPath = downloadedBinPath(pkg, subpath); try { console.error(`[esbuild] Trying to install package "${pkg}" using npm`); @@ -275,7 +289,7 @@ this. If that fails, you need to remove the "--no-optional" flag to use esbuild. } } } - maybeOptimizePackage(binPath); + maybeOptimizePackage(binPath, isWASM); } checkAndPreparePackage().then(() => { if (isToPathJS) { diff --git a/static/node_modules/esbuild/lib/main.d.ts b/static/node_modules/esbuild/lib/main.d.ts index c705307..9d9974b 100644 --- a/static/node_modules/esbuild/lib/main.d.ts +++ b/static/node_modules/esbuild/lib/main.d.ts @@ -2,8 +2,10 @@ export type Platform = 'browser' | 'node' | 'neutral' export type Format = 'iife' | 'cjs' | 'esm' export type Loader = 'base64' | 'binary' | 'copy' | 'css' | 'dataurl' | 'default' | 'empty' | 'file' | 'js' | 'json' | 'jsx' | 'local-css' | 'text' | 'ts' | 'tsx' export type LogLevel = 'verbose' | 'debug' | 'info' | 'warning' | 'error' | 'silent' +export type LogStyle = 'default' | 'visualstudio' export type Charset = 'ascii' | 'utf8' export type Drop = 'console' | 'debugger' +export type AbsPaths = 'code' | 'log' | 'metafile' interface CommonOptions { /** Documentation: https://esbuild.github.io/api/#sourcemap */ @@ -75,6 +77,8 @@ interface CommonOptions { /** Documentation: https://esbuild.github.io/api/#keep-names */ keepNames?: boolean + /** Documentation: https://esbuild.github.io/api/#abs-paths */ + absPaths?: AbsPaths[] /** Documentation: https://esbuild.github.io/api/#color */ color?: boolean /** Documentation: https://esbuild.github.io/api/#log-level */ @@ -83,6 +87,8 @@ interface CommonOptions { logLimit?: number /** Documentation: https://esbuild.github.io/api/#log-override */ logOverride?: Record + /** Documentation: https://esbuild.github.io/api/#log-style */ + logStyle?: LogStyle /** Documentation: https://esbuild.github.io/api/#tsconfig-raw */ tsconfigRaw?: string | TsconfigRaw @@ -159,7 +165,7 @@ export interface BuildOptions extends CommonOptions { /** Documentation: https://esbuild.github.io/api/#footer */ footer?: { [type: string]: string } /** Documentation: https://esbuild.github.io/api/#entry-points */ - entryPoints?: string[] | Record | { in: string, out: string }[] + entryPoints?: (string | { in: string, out: string })[] | Record /** Documentation: https://esbuild.github.io/api/#stdin */ stdin?: StdinOptions /** Documentation: https://esbuild.github.io/plugins/ */ @@ -241,9 +247,15 @@ export interface ServeOptions { keyfile?: string certfile?: string fallback?: string + cors?: CORSOptions onRequest?: (args: ServeOnRequestArgs) => void } +/** Documentation: https://esbuild.github.io/api/#cors */ +export interface CORSOptions { + origin?: string | string[] +} + export interface ServeOnRequestArgs { remoteAddress: string method: string @@ -256,7 +268,7 @@ export interface ServeOnRequestArgs { /** Documentation: https://esbuild.github.io/api/#serve-return-values */ export interface ServeResult { port: number - host: string + hosts: string[] } export interface TransformOptions extends CommonOptions { @@ -500,6 +512,7 @@ export interface FormatMessagesOptions { kind: 'error' | 'warning' color?: boolean terminalWidth?: number + logStyle?: LogStyle } export interface AnalyzeMetafileOptions { @@ -507,7 +520,9 @@ export interface AnalyzeMetafileOptions { verbose?: boolean } +/** Documentation: https://esbuild.github.io/api/#watch-arguments */ export interface WatchOptions { + delay?: number // In milliseconds } export interface BuildContext { diff --git a/static/node_modules/esbuild/lib/main.js b/static/node_modules/esbuild/lib/main.js index e779b97..6126744 100644 --- a/static/node_modules/esbuild/lib/main.js +++ b/static/node_modules/esbuild/lib/main.js @@ -205,7 +205,7 @@ esbuild in this environment because esbuild relies on this invariant. This is not a problem with esbuild. You need to fix your environment instead. `); function readUInt32LE(buffer, offset) { - return buffer[offset++] | buffer[offset++] << 8 | buffer[offset++] << 16 | buffer[offset++] << 24; + return (buffer[offset++] | buffer[offset++] << 8 | buffer[offset++] << 16 | buffer[offset++] << 24) >>> 0; } function writeUInt32LE(buffer, value, offset) { buffer[offset++] = value; @@ -214,29 +214,316 @@ function writeUInt32LE(buffer, value, offset) { buffer[offset++] = value >> 24; } +// lib/shared/uint8array_json_parser.ts +var fromCharCode = String.fromCharCode; +function throwSyntaxError(bytes, index, message) { + const c = bytes[index]; + let line = 1; + let column = 0; + for (let i = 0; i < index; i++) { + if (bytes[i] === 10 /* Newline */) { + line++; + column = 0; + } else { + column++; + } + } + throw new SyntaxError( + message ? message : index === bytes.length ? "Unexpected end of input while parsing JSON" : c >= 32 && c <= 126 ? `Unexpected character ${fromCharCode(c)} in JSON at position ${index} (line ${line}, column ${column})` : `Unexpected byte 0x${c.toString(16)} in JSON at position ${index} (line ${line}, column ${column})` + ); +} +function JSON_parse(bytes) { + if (!(bytes instanceof Uint8Array)) { + throw new Error(`JSON input must be a Uint8Array`); + } + const propertyStack = []; + const objectStack = []; + const stateStack = []; + const length = bytes.length; + let property = null; + let state = 0 /* TopLevel */; + let object; + let i = 0; + while (i < length) { + let c = bytes[i++]; + if (c <= 32 /* Space */) { + continue; + } + let value; + if (state === 2 /* Object */ && property === null && c !== 34 /* Quote */ && c !== 125 /* CloseBrace */) { + throwSyntaxError(bytes, --i); + } + switch (c) { + // True + case 116 /* LowerT */: { + if (bytes[i++] !== 114 /* LowerR */ || bytes[i++] !== 117 /* LowerU */ || bytes[i++] !== 101 /* LowerE */) { + throwSyntaxError(bytes, --i); + } + value = true; + break; + } + // False + case 102 /* LowerF */: { + if (bytes[i++] !== 97 /* LowerA */ || bytes[i++] !== 108 /* LowerL */ || bytes[i++] !== 115 /* LowerS */ || bytes[i++] !== 101 /* LowerE */) { + throwSyntaxError(bytes, --i); + } + value = false; + break; + } + // Null + case 110 /* LowerN */: { + if (bytes[i++] !== 117 /* LowerU */ || bytes[i++] !== 108 /* LowerL */ || bytes[i++] !== 108 /* LowerL */) { + throwSyntaxError(bytes, --i); + } + value = null; + break; + } + // Number begin + case 45 /* Minus */: + case 46 /* Dot */: + case 48 /* Digit0 */: + case 49 /* Digit1 */: + case 50 /* Digit2 */: + case 51 /* Digit3 */: + case 52 /* Digit4 */: + case 53 /* Digit5 */: + case 54 /* Digit6 */: + case 55 /* Digit7 */: + case 56 /* Digit8 */: + case 57 /* Digit9 */: { + let index = i; + value = fromCharCode(c); + c = bytes[i]; + while (true) { + switch (c) { + case 43 /* Plus */: + case 45 /* Minus */: + case 46 /* Dot */: + case 48 /* Digit0 */: + case 49 /* Digit1 */: + case 50 /* Digit2 */: + case 51 /* Digit3 */: + case 52 /* Digit4 */: + case 53 /* Digit5 */: + case 54 /* Digit6 */: + case 55 /* Digit7 */: + case 56 /* Digit8 */: + case 57 /* Digit9 */: + case 101 /* LowerE */: + case 69 /* UpperE */: { + value += fromCharCode(c); + c = bytes[++i]; + continue; + } + } + break; + } + value = +value; + if (isNaN(value)) { + throwSyntaxError(bytes, --index, "Invalid number"); + } + break; + } + // String begin + case 34 /* Quote */: { + value = ""; + while (true) { + if (i >= length) { + throwSyntaxError(bytes, length); + } + c = bytes[i++]; + if (c === 34 /* Quote */) { + break; + } else if (c === 92 /* Backslash */) { + switch (bytes[i++]) { + // Normal escape sequence + case 34 /* Quote */: + value += '"'; + break; + case 47 /* Slash */: + value += "/"; + break; + case 92 /* Backslash */: + value += "\\"; + break; + case 98 /* LowerB */: + value += "\b"; + break; + case 102 /* LowerF */: + value += "\f"; + break; + case 110 /* LowerN */: + value += "\n"; + break; + case 114 /* LowerR */: + value += "\r"; + break; + case 116 /* LowerT */: + value += " "; + break; + // Unicode escape sequence + case 117 /* LowerU */: { + let code = 0; + for (let j = 0; j < 4; j++) { + c = bytes[i++]; + code <<= 4; + if (c >= 48 /* Digit0 */ && c <= 57 /* Digit9 */) code |= c - 48 /* Digit0 */; + else if (c >= 97 /* LowerA */ && c <= 102 /* LowerF */) code |= c + (10 - 97 /* LowerA */); + else if (c >= 65 /* UpperA */ && c <= 70 /* UpperF */) code |= c + (10 - 65 /* UpperA */); + else throwSyntaxError(bytes, --i); + } + value += fromCharCode(code); + break; + } + // Invalid escape sequence + default: + throwSyntaxError(bytes, --i); + break; + } + } else if (c <= 127) { + value += fromCharCode(c); + } else if ((c & 224) === 192) { + value += fromCharCode((c & 31) << 6 | bytes[i++] & 63); + } else if ((c & 240) === 224) { + value += fromCharCode((c & 15) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63); + } else if ((c & 248) == 240) { + let codePoint = (c & 7) << 18 | (bytes[i++] & 63) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63; + if (codePoint > 65535) { + codePoint -= 65536; + value += fromCharCode(codePoint >> 10 & 1023 | 55296); + codePoint = 56320 | codePoint & 1023; + } + value += fromCharCode(codePoint); + } + } + value[0]; + break; + } + // Array begin + case 91 /* OpenBracket */: { + value = []; + propertyStack.push(property); + objectStack.push(object); + stateStack.push(state); + property = null; + object = value; + state = 1 /* Array */; + continue; + } + // Object begin + case 123 /* OpenBrace */: { + value = {}; + propertyStack.push(property); + objectStack.push(object); + stateStack.push(state); + property = null; + object = value; + state = 2 /* Object */; + continue; + } + // Array end + case 93 /* CloseBracket */: { + if (state !== 1 /* Array */) { + throwSyntaxError(bytes, --i); + } + value = object; + property = propertyStack.pop(); + object = objectStack.pop(); + state = stateStack.pop(); + break; + } + // Object end + case 125 /* CloseBrace */: { + if (state !== 2 /* Object */) { + throwSyntaxError(bytes, --i); + } + value = object; + property = propertyStack.pop(); + object = objectStack.pop(); + state = stateStack.pop(); + break; + } + default: { + throwSyntaxError(bytes, --i); + } + } + c = bytes[i]; + while (c <= 32 /* Space */) { + c = bytes[++i]; + } + switch (state) { + case 0 /* TopLevel */: { + if (i === length) { + return value; + } + break; + } + case 1 /* Array */: { + object.push(value); + if (c === 44 /* Comma */) { + i++; + continue; + } + if (c === 93 /* CloseBracket */) { + continue; + } + break; + } + case 2 /* Object */: { + if (property === null) { + property = value; + if (c === 58 /* Colon */) { + i++; + continue; + } + } else { + object[property] = value; + property = null; + if (c === 44 /* Comma */) { + i++; + continue; + } + if (c === 125 /* CloseBrace */) { + continue; + } + } + break; + } + } + break; + } + throwSyntaxError(bytes, i); +} + // lib/shared/common.ts var quote = JSON.stringify; var buildLogLevelDefault = "warning"; var transformLogLevelDefault = "silent"; -function validateTarget(target) { - validateStringValue(target, "target"); - if (target.indexOf(",") >= 0) throw new Error(`Invalid target: ${target}`); - return target; +function validateAndJoinStringArray(values, what) { + const toJoin = []; + for (const value of values) { + validateStringValue(value, what); + if (value.indexOf(",") >= 0) throw new Error(`Invalid ${what}: ${value}`); + toJoin.push(value); + } + return toJoin.join(","); } var canBeAnything = () => null; var mustBeBoolean = (value) => typeof value === "boolean" ? null : "a boolean"; var mustBeString = (value) => typeof value === "string" ? null : "a string"; var mustBeRegExp = (value) => value instanceof RegExp ? null : "a RegExp object"; var mustBeInteger = (value) => typeof value === "number" && value === (value | 0) ? null : "an integer"; +var mustBeValidPortNumber = (value) => typeof value === "number" && value === (value | 0) && value >= 0 && value <= 65535 ? null : "a valid port number"; var mustBeFunction = (value) => typeof value === "function" ? null : "a function"; var mustBeArray = (value) => Array.isArray(value) ? null : "an array"; +var mustBeArrayOfStrings = (value) => Array.isArray(value) && value.every((x) => typeof x === "string") ? null : "an array of strings"; var mustBeObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? null : "an object"; var mustBeEntryPoints = (value) => typeof value === "object" && value !== null ? null : "an array or an object"; var mustBeWebAssemblyModule = (value) => value instanceof WebAssembly.Module ? null : "a WebAssembly.Module"; var mustBeObjectOrNull = (value) => typeof value === "object" && !Array.isArray(value) ? null : "an object or null"; var mustBeStringOrBoolean = (value) => typeof value === "string" || typeof value === "boolean" ? null : "a string or a boolean"; var mustBeStringOrObject = (value) => typeof value === "string" || typeof value === "object" && value !== null && !Array.isArray(value) ? null : "a string or an object"; -var mustBeStringOrArray = (value) => typeof value === "string" || Array.isArray(value) ? null : "a string or an array"; +var mustBeStringOrArrayOfStrings = (value) => typeof value === "string" || Array.isArray(value) && value.every((x) => typeof x === "string") ? null : "a string or an array of strings"; var mustBeStringOrUint8Array = (value) => typeof value === "string" || value instanceof Uint8Array ? null : "a string or a Uint8Array"; var mustBeStringOrURL = (value) => typeof value === "string" || value instanceof URL ? null : "a string or a URL"; function getFlag(object, keys, key, mustBeFn) { @@ -285,10 +572,12 @@ function pushLogFlags(flags, options, keys, isTTY2, logLevelDefault) { let color = getFlag(options, keys, "color", mustBeBoolean); let logLevel = getFlag(options, keys, "logLevel", mustBeString); let logLimit = getFlag(options, keys, "logLimit", mustBeInteger); + let logStyle = getFlag(options, keys, "logStyle", mustBeString); if (color !== void 0) flags.push(`--color=${color}`); else if (isTTY2) flags.push(`--color=true`); flags.push(`--log-level=${logLevel || logLevelDefault}`); flags.push(`--log-limit=${logLimit || 0}`); + if (logStyle) flags.push(`--log-style=${logStyle}`); } function validateStringValue(value, what, key) { if (typeof value !== "string") { @@ -300,7 +589,7 @@ function pushCommonFlags(flags, options, keys) { let legalComments = getFlag(options, keys, "legalComments", mustBeString); let sourceRoot = getFlag(options, keys, "sourceRoot", mustBeString); let sourcesContent = getFlag(options, keys, "sourcesContent", mustBeBoolean); - let target = getFlag(options, keys, "target", mustBeStringOrArray); + let target = getFlag(options, keys, "target", mustBeStringOrArrayOfStrings); let format = getFlag(options, keys, "format", mustBeString); let globalName = getFlag(options, keys, "globalName", mustBeString); let mangleProps = getFlag(options, keys, "mangleProps", mustBeRegExp); @@ -311,8 +600,8 @@ function pushCommonFlags(flags, options, keys) { let minifyWhitespace = getFlag(options, keys, "minifyWhitespace", mustBeBoolean); let minifyIdentifiers = getFlag(options, keys, "minifyIdentifiers", mustBeBoolean); let lineLimit = getFlag(options, keys, "lineLimit", mustBeInteger); - let drop = getFlag(options, keys, "drop", mustBeArray); - let dropLabels = getFlag(options, keys, "dropLabels", mustBeArray); + let drop = getFlag(options, keys, "drop", mustBeArrayOfStrings); + let dropLabels = getFlag(options, keys, "dropLabels", mustBeArrayOfStrings); let charset = getFlag(options, keys, "charset", mustBeString); let treeShaking = getFlag(options, keys, "treeShaking", mustBeBoolean); let ignoreAnnotations = getFlag(options, keys, "ignoreAnnotations", mustBeBoolean); @@ -325,17 +614,15 @@ function pushCommonFlags(flags, options, keys) { let define = getFlag(options, keys, "define", mustBeObject); let logOverride = getFlag(options, keys, "logOverride", mustBeObject); let supported = getFlag(options, keys, "supported", mustBeObject); - let pure = getFlag(options, keys, "pure", mustBeArray); + let pure = getFlag(options, keys, "pure", mustBeArrayOfStrings); let keepNames = getFlag(options, keys, "keepNames", mustBeBoolean); let platform = getFlag(options, keys, "platform", mustBeString); let tsconfigRaw = getFlag(options, keys, "tsconfigRaw", mustBeStringOrObject); + let absPaths = getFlag(options, keys, "absPaths", mustBeArrayOfStrings); if (legalComments) flags.push(`--legal-comments=${legalComments}`); if (sourceRoot !== void 0) flags.push(`--source-root=${sourceRoot}`); if (sourcesContent !== void 0) flags.push(`--sources-content=${sourcesContent}`); - if (target) { - if (Array.isArray(target)) flags.push(`--target=${Array.from(target).map(validateTarget).join(",")}`); - else flags.push(`--target=${validateTarget(target)}`); - } + if (target) flags.push(`--target=${validateAndJoinStringArray(Array.isArray(target) ? target : [target], "target")}`); if (format) flags.push(`--format=${format}`); if (globalName) flags.push(`--global-name=${globalName}`); if (platform) flags.push(`--platform=${platform}`); @@ -349,9 +636,10 @@ function pushCommonFlags(flags, options, keys) { if (treeShaking !== void 0) flags.push(`--tree-shaking=${treeShaking}`); if (ignoreAnnotations) flags.push(`--ignore-annotations`); if (drop) for (let what of drop) flags.push(`--drop:${validateStringValue(what, "drop")}`); - if (dropLabels) flags.push(`--drop-labels=${Array.from(dropLabels).map((what) => validateStringValue(what, "dropLabels")).join(",")}`); - if (mangleProps) flags.push(`--mangle-props=${mangleProps.source}`); - if (reserveProps) flags.push(`--reserve-props=${reserveProps.source}`); + if (dropLabels) flags.push(`--drop-labels=${validateAndJoinStringArray(dropLabels, "drop label")}`); + if (absPaths) flags.push(`--abs-paths=${validateAndJoinStringArray(absPaths, "abs paths")}`); + if (mangleProps) flags.push(`--mangle-props=${jsRegExpToGoRegExp(mangleProps)}`); + if (reserveProps) flags.push(`--reserve-props=${jsRegExpToGoRegExp(reserveProps)}`); if (mangleQuoted !== void 0) flags.push(`--mangle-quoted=${mangleQuoted}`); if (jsx) flags.push(`--jsx=${jsx}`); if (jsxFactory) flags.push(`--jsx-factory=${jsxFactory}`); @@ -400,11 +688,11 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD let outdir = getFlag(options, keys, "outdir", mustBeString); let outbase = getFlag(options, keys, "outbase", mustBeString); let tsconfig = getFlag(options, keys, "tsconfig", mustBeString); - let resolveExtensions = getFlag(options, keys, "resolveExtensions", mustBeArray); - let nodePathsInput = getFlag(options, keys, "nodePaths", mustBeArray); - let mainFields = getFlag(options, keys, "mainFields", mustBeArray); - let conditions = getFlag(options, keys, "conditions", mustBeArray); - let external = getFlag(options, keys, "external", mustBeArray); + let resolveExtensions = getFlag(options, keys, "resolveExtensions", mustBeArrayOfStrings); + let nodePathsInput = getFlag(options, keys, "nodePaths", mustBeArrayOfStrings); + let mainFields = getFlag(options, keys, "mainFields", mustBeArrayOfStrings); + let conditions = getFlag(options, keys, "conditions", mustBeArrayOfStrings); + let external = getFlag(options, keys, "external", mustBeArrayOfStrings); let packages = getFlag(options, keys, "packages", mustBeString); let alias = getFlag(options, keys, "alias", mustBeObject); let loader = getFlag(options, keys, "loader", mustBeObject); @@ -413,7 +701,7 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD let entryNames = getFlag(options, keys, "entryNames", mustBeString); let chunkNames = getFlag(options, keys, "chunkNames", mustBeString); let assetNames = getFlag(options, keys, "assetNames", mustBeString); - let inject = getFlag(options, keys, "inject", mustBeArray); + let inject = getFlag(options, keys, "inject", mustBeArrayOfStrings); let banner = getFlag(options, keys, "banner", mustBeObject); let footer = getFlag(options, keys, "footer", mustBeObject); let entryPoints = getFlag(options, keys, "entryPoints", mustBeEntryPoints); @@ -435,37 +723,13 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD if (outbase) flags.push(`--outbase=${outbase}`); if (tsconfig) flags.push(`--tsconfig=${tsconfig}`); if (packages) flags.push(`--packages=${packages}`); - if (resolveExtensions) { - let values = []; - for (let value of resolveExtensions) { - validateStringValue(value, "resolve extension"); - if (value.indexOf(",") >= 0) throw new Error(`Invalid resolve extension: ${value}`); - values.push(value); - } - flags.push(`--resolve-extensions=${values.join(",")}`); - } + if (resolveExtensions) flags.push(`--resolve-extensions=${validateAndJoinStringArray(resolveExtensions, "resolve extension")}`); if (publicPath) flags.push(`--public-path=${publicPath}`); if (entryNames) flags.push(`--entry-names=${entryNames}`); if (chunkNames) flags.push(`--chunk-names=${chunkNames}`); if (assetNames) flags.push(`--asset-names=${assetNames}`); - if (mainFields) { - let values = []; - for (let value of mainFields) { - validateStringValue(value, "main field"); - if (value.indexOf(",") >= 0) throw new Error(`Invalid main field: ${value}`); - values.push(value); - } - flags.push(`--main-fields=${values.join(",")}`); - } - if (conditions) { - let values = []; - for (let value of conditions) { - validateStringValue(value, "condition"); - if (value.indexOf(",") >= 0) throw new Error(`Invalid condition: ${value}`); - values.push(value); - } - flags.push(`--conditions=${values.join(",")}`); - } + if (mainFields) flags.push(`--main-fields=${validateAndJoinStringArray(mainFields, "main field")}`); + if (conditions) flags.push(`--conditions=${validateAndJoinStringArray(conditions, "condition")}`); if (external) for (let name of external) flags.push(`--external:${validateStringValue(name, "external")}`); if (alias) { for (let old in alias) { @@ -662,8 +926,8 @@ function createChannel(streamIn) { if (isFirstPacket) { isFirstPacket = false; let binaryVersion = String.fromCharCode(...bytes); - if (binaryVersion !== "0.23.0") { - throw new Error(`Cannot start service: Host version "${"0.23.0"}" does not match binary version ${quote(binaryVersion)}`); + if (binaryVersion !== "0.28.2") { + throw new Error(`Cannot start service: Host version "${"0.28.2"}" does not match binary version ${quote(binaryVersion)}`); } return; } @@ -802,6 +1066,7 @@ function createChannel(streamIn) { let kind = getFlag(options, keys, "kind", mustBeString); let color = getFlag(options, keys, "color", mustBeBoolean); let terminalWidth = getFlag(options, keys, "terminalWidth", mustBeInteger); + let logStyle = getFlag(options, keys, "logStyle", mustBeString); checkForInvalidFlags(options, keys, `in ${callName}() call`); if (kind === void 0) throw new Error(`Missing "kind" in ${callName}() call`); if (kind !== "error" && kind !== "warning") throw new Error(`Expected "kind" to be "error" or "warning" in ${callName}() call`); @@ -812,6 +1077,7 @@ function createChannel(streamIn) { }; if (color !== void 0) request.color = color; if (terminalWidth !== void 0) request.terminalWidth = terminalWidth; + if (logStyle !== void 0) request.logStyle = logStyle; sendRequest(refs, request, (error, response) => { if (error) return callback(new Error(error), null); callback(null, response.messages); @@ -937,7 +1203,7 @@ function buildOrContextImpl(callName, buildKey, sendRequest, sendResponse, refs, const originalErrors = result.errors.slice(); const originalWarnings = result.warnings.slice(); if (response.outputFiles) result.outputFiles = response.outputFiles.map(convertOutputFiles); - if (response.metafile) result.metafile = JSON.parse(response.metafile); + if (response.metafile && response.metafile.length) result.metafile = parseJSON(response.metafile); if (response.mangleCache) result.mangleCache = response.mangleCache; if (response.writeToStdout !== void 0) console.log(decodeUTF8(response.writeToStdout).replace(/\n$/, "")); runOnEndCallbacks(result, (onEndErrors, onEndWarnings) => { @@ -1005,11 +1271,13 @@ function buildOrContextImpl(callName, buildKey, sendRequest, sendResponse, refs, watch: (options2 = {}) => new Promise((resolve, reject) => { if (!streamIn.hasFS) throw new Error(`Cannot use the "watch" API in this environment`); const keys = {}; + const delay = getFlag(options2, keys, "delay", mustBeInteger); checkForInvalidFlags(options2, keys, `in watch() call`); const request2 = { command: "watch", key: buildKey }; + if (delay) request2.delay = delay; sendRequest(refs, request2, (error2) => { if (error2) reject(new Error(error2)); else resolve(void 0); @@ -1018,12 +1286,13 @@ function buildOrContextImpl(callName, buildKey, sendRequest, sendResponse, refs, serve: (options2 = {}) => new Promise((resolve, reject) => { if (!streamIn.hasFS) throw new Error(`Cannot use the "serve" API in this environment`); const keys = {}; - const port = getFlag(options2, keys, "port", mustBeInteger); + const port = getFlag(options2, keys, "port", mustBeValidPortNumber); const host = getFlag(options2, keys, "host", mustBeString); const servedir = getFlag(options2, keys, "servedir", mustBeString); const keyfile = getFlag(options2, keys, "keyfile", mustBeString); const certfile = getFlag(options2, keys, "certfile", mustBeString); const fallback = getFlag(options2, keys, "fallback", mustBeString); + const cors = getFlag(options2, keys, "cors", mustBeObject); const onRequest = getFlag(options2, keys, "onRequest", mustBeFunction); checkForInvalidFlags(options2, keys, `in serve() call`); const request2 = { @@ -1037,6 +1306,13 @@ function buildOrContextImpl(callName, buildKey, sendRequest, sendResponse, refs, if (keyfile !== void 0) request2.keyfile = keyfile; if (certfile !== void 0) request2.certfile = certfile; if (fallback !== void 0) request2.fallback = fallback; + if (cors) { + const corsKeys = {}; + const origin = getFlag(cors, corsKeys, "origin", mustBeStringOrArrayOfStrings); + checkForInvalidFlags(cors, corsKeys, `on "cors" object`); + if (Array.isArray(origin)) request2.corsOrigin = origin; + else if (origin !== void 0) request2.corsOrigin = [origin]; + } sendRequest(refs, request2, (error2, response2) => { if (error2) return reject(new Error(error2)); if (onRequest) { @@ -1172,7 +1448,7 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn, if (filter == null) throw new Error(`onResolve() call is missing a filter`); let id = nextCallbackID++; onResolveCallbacks[id] = { name, callback, note: registeredNote }; - plugin.onResolve.push({ id, filter: filter.source, namespace: namespace || "" }); + plugin.onResolve.push({ id, filter: jsRegExpToGoRegExp(filter), namespace: namespace || "" }); }, onLoad(options, callback) { let registeredText = `This error came from the "onLoad" callback registered here:`; @@ -1184,7 +1460,7 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn, if (filter == null) throw new Error(`onLoad() call is missing a filter`); let id = nextCallbackID++; onLoadCallbacks[id] = { name, callback, note: registeredNote }; - plugin.onLoad.push({ id, filter: filter.source, namespace: namespace || "" }); + plugin.onLoad.push({ id, filter: jsRegExpToGoRegExp(filter), namespace: namespace || "" }); }, onDispose(callback) { onDisposeCallbacks.push(callback); @@ -1198,6 +1474,7 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn, } } requestCallbacks["on-start"] = async (id, request) => { + details.clear(); let response = { errors: [], warnings: [] }; await Promise.all(onStartCallbacks.map(async ({ name, callback, note }) => { try { @@ -1243,8 +1520,8 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn, let pluginData = getFlag(result, keys, "pluginData", canBeAnything); let errors = getFlag(result, keys, "errors", mustBeArray); let warnings = getFlag(result, keys, "warnings", mustBeArray); - let watchFiles = getFlag(result, keys, "watchFiles", mustBeArray); - let watchDirs = getFlag(result, keys, "watchDirs", mustBeArray); + let watchFiles = getFlag(result, keys, "watchFiles", mustBeArrayOfStrings); + let watchDirs = getFlag(result, keys, "watchDirs", mustBeArrayOfStrings); checkForInvalidFlags(result, keys, `from onResolve() callback in plugin ${quote(name)}`); response.id = id2; if (pluginName != null) response.pluginName = pluginName; @@ -1289,8 +1566,8 @@ var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn, let loader = getFlag(result, keys, "loader", mustBeString); let errors = getFlag(result, keys, "errors", mustBeArray); let warnings = getFlag(result, keys, "warnings", mustBeArray); - let watchFiles = getFlag(result, keys, "watchFiles", mustBeArray); - let watchDirs = getFlag(result, keys, "watchDirs", mustBeArray); + let watchFiles = getFlag(result, keys, "watchFiles", mustBeArrayOfStrings); + let watchDirs = getFlag(result, keys, "watchDirs", mustBeArrayOfStrings); checkForInvalidFlags(result, keys, `from onLoad() callback in plugin ${quote(name)}`); response.id = id2; if (pluginName != null) response.pluginName = pluginName; @@ -1371,6 +1648,9 @@ function createObjectStash() { const map = /* @__PURE__ */ new Map(); let nextID = 0; return { + clear() { + map.clear(); + }, load(id) { return map.get(id); }, @@ -1591,6 +1871,20 @@ function convertOutputFiles({ path: path3, contents, hash }) { } }; } +function jsRegExpToGoRegExp(regexp) { + let result = regexp.source; + if (regexp.flags) result = `(?${regexp.flags})${result}`; + return result; +} +function parseJSON(bytes) { + let text; + try { + text = decodeUTF8(bytes); + } catch { + return JSON_parse(bytes); + } + return JSON.parse(text); +} // lib/npm/node-platform.ts var fs = require("fs"); @@ -1621,6 +1915,7 @@ var knownUnixlikePackages = { "linux s390x BE": "@esbuild/linux-s390x", "linux x64 LE": "@esbuild/linux-x64", "linux loong64 LE": "@esbuild/linux-loong64", + "netbsd arm64 LE": "@esbuild/netbsd-arm64", "netbsd x64 LE": "@esbuild/netbsd-x64", "openbsd arm64 LE": "@esbuild/openbsd-arm64", "openbsd x64 LE": "@esbuild/openbsd-x64", @@ -1628,7 +1923,8 @@ var knownUnixlikePackages = { }; var knownWebAssemblyFallbackPackages = { "android arm LE": "@esbuild/android-arm", - "android x64 LE": "@esbuild/android-x64" + "android x64 LE": "@esbuild/android-x64", + "openharmony arm64 LE": "@esbuild/openharmony-arm64" }; function pkgAndSubpathForCurrentPlatform() { let pkg; @@ -1768,7 +2064,7 @@ for your current platform.`); "node_modules", ".cache", "esbuild", - `pnpapi-${pkg.replace("/", "-")}-${"0.23.0"}-${path.basename(subpath)}` + `pnpapi-${pkg.replace("/", "-")}-${"0.28.2"}-${path.basename(subpath)}` ); if (!fs.existsSync(binTargetPath)) { fs.mkdirSync(path.dirname(binTargetPath), { recursive: true }); @@ -1803,7 +2099,7 @@ if (process.env.ESBUILD_WORKER_THREADS !== "0") { } } var _a; -var isInternalWorkerThread = ((_a = worker_threads == null ? void 0 : worker_threads.workerData) == null ? void 0 : _a.esbuildVersion) === "0.23.0"; +var isInternalWorkerThread = ((_a = worker_threads == null ? void 0 : worker_threads.workerData) == null ? void 0 : _a.esbuildVersion) === "0.28.2"; var esbuildCommandAndArgs = () => { if ((!ESBUILD_BINARY_PATH || false) && (path2.basename(__filename) !== "main.js" || path2.basename(__dirname) !== "lib")) { throw new Error( @@ -1870,7 +2166,7 @@ var fsAsync = { } } }; -var version = "0.23.0"; +var version = "0.28.2"; var build = (options) => ensureServiceIsRunning().build(options); var context = (buildOptions) => ensureServiceIsRunning().context(buildOptions); var transform = (input, options) => ensureServiceIsRunning().transform(input, options); @@ -1973,7 +2269,7 @@ var stopService; var ensureServiceIsRunning = () => { if (longLivedService) return longLivedService; let [command, args] = esbuildCommandAndArgs(); - let child = child_process.spawn(command, args.concat(`--service=${"0.23.0"}`, "--ping"), { + let child = child_process.spawn(command, args.concat(`--service=${"0.28.2"}`, "--ping"), { windowsHide: true, stdio: ["pipe", "pipe", "inherit"], cwd: defaultWD @@ -2077,7 +2373,7 @@ var runServiceSync = (callback) => { esbuild: node_exports }); callback(service); - let stdout = child_process.execFileSync(command, args.concat(`--service=${"0.23.0"}`), { + let stdout = child_process.execFileSync(command, args.concat(`--service=${"0.28.2"}`), { cwd: defaultWD, windowsHide: true, input: stdin, @@ -2097,7 +2393,7 @@ var workerThreadService = null; var startWorkerThreadService = (worker_threads2) => { let { port1: mainPort, port2: workerPort } = new worker_threads2.MessageChannel(); let worker = new worker_threads2.Worker(__filename, { - workerData: { workerPort, defaultWD, esbuildVersion: "0.23.0" }, + workerData: { workerPort, defaultWD, esbuildVersion: "0.28.2" }, transferList: [workerPort], // From node's documentation: https://nodejs.org/api/worker_threads.html // diff --git a/static/node_modules/esbuild/package.json b/static/node_modules/esbuild/package.json index 9fa9264..7e54c6f 100644 --- a/static/node_modules/esbuild/package.json +++ b/static/node_modules/esbuild/package.json @@ -1,6 +1,6 @@ { "name": "esbuild", - "version": "0.23.0", + "version": "0.28.2", "description": "An extremely fast JavaScript and CSS bundler and minifier.", "repository": { "type": "git", @@ -18,30 +18,57 @@ "esbuild": "bin/esbuild" }, "optionalDependencies": { - "@esbuild/aix-ppc64": "0.23.0", - "@esbuild/android-arm": "0.23.0", - "@esbuild/android-arm64": "0.23.0", - "@esbuild/android-x64": "0.23.0", - "@esbuild/darwin-arm64": "0.23.0", - "@esbuild/darwin-x64": "0.23.0", - "@esbuild/freebsd-arm64": "0.23.0", - "@esbuild/freebsd-x64": "0.23.0", - "@esbuild/linux-arm": "0.23.0", - "@esbuild/linux-arm64": "0.23.0", - "@esbuild/linux-ia32": "0.23.0", - "@esbuild/linux-loong64": "0.23.0", - "@esbuild/linux-mips64el": "0.23.0", - "@esbuild/linux-ppc64": "0.23.0", - "@esbuild/linux-riscv64": "0.23.0", - "@esbuild/linux-s390x": "0.23.0", - "@esbuild/linux-x64": "0.23.0", - "@esbuild/netbsd-x64": "0.23.0", - "@esbuild/openbsd-arm64": "0.23.0", - "@esbuild/openbsd-x64": "0.23.0", - "@esbuild/sunos-x64": "0.23.0", - "@esbuild/win32-arm64": "0.23.0", - "@esbuild/win32-ia32": "0.23.0", - "@esbuild/win32-x64": "0.23.0" + "@esbuild/aix-ppc64": "0.28.2", + "@esbuild/android-arm": "0.28.2", + "@esbuild/android-arm64": "0.28.2", + "@esbuild/android-x64": "0.28.2", + "@esbuild/darwin-arm64": "0.28.2", + "@esbuild/darwin-x64": "0.28.2", + "@esbuild/freebsd-arm64": "0.28.2", + "@esbuild/freebsd-x64": "0.28.2", + "@esbuild/linux-arm": "0.28.2", + "@esbuild/linux-arm64": "0.28.2", + "@esbuild/linux-ia32": "0.28.2", + "@esbuild/linux-loong64": "0.28.2", + "@esbuild/linux-mips64el": "0.28.2", + "@esbuild/linux-ppc64": "0.28.2", + "@esbuild/linux-riscv64": "0.28.2", + "@esbuild/linux-s390x": "0.28.2", + "@esbuild/linux-x64": "0.28.2", + "@esbuild/netbsd-arm64": "0.28.2", + "@esbuild/netbsd-x64": "0.28.2", + "@esbuild/openbsd-arm64": "0.28.2", + "@esbuild/openbsd-x64": "0.28.2", + "@esbuild/openharmony-arm64": "0.28.2", + "@esbuild/sunos-x64": "0.28.2", + "@esbuild/win32-arm64": "0.28.2", + "@esbuild/win32-ia32": "0.28.2", + "@esbuild/win32-x64": "0.28.2" }, - "license": "MIT" + "license": "MIT", + "esbuild.binaryHashes": { + "@esbuild/aix-ppc64/bin/esbuild": "6de148b932fc5d3b28a97f9f0bc4de8e2b47db478b8ad679e0eaa6b96e00420d", + "@esbuild/android-arm64/bin/esbuild": "84efbbd2cbf21bbfec2aaf304bee79cb2a4a05fe2ea7b861a87f7b8f213ac27d", + "@esbuild/darwin-arm64/bin/esbuild": "10b6243df618d374bb2d5c9cfbe7052e1405f6aa4e53a6164f11a91b9f2e1384", + "@esbuild/darwin-x64/bin/esbuild": "7fe5c9c905fff0a05d92db98929434ab4d3b6dd92d7a7688922db74380c75df3", + "@esbuild/freebsd-arm64/bin/esbuild": "6aba108a68b93064e491bfb1ecfa28843b4d4e504dff0627f53f68f6bb015c01", + "@esbuild/freebsd-x64/bin/esbuild": "8a237e222bee0e50556e7b00d83ec2ff43721bf72f19811a5f0ee56f1d40177c", + "@esbuild/linux-arm/bin/esbuild": "d88f751b22095b2f3b42c8c2e8a3f36fabc1705438c5d6e78366b681f8b4e7a5", + "@esbuild/linux-arm64/bin/esbuild": "90bd269553d258e80b19e3ccab4f98f0831f87442a2f056510ce24fd1b425fc2", + "@esbuild/linux-ia32/bin/esbuild": "b1e2d87d79f9a2baa0d3043cdf0dc6716f9f2eea66c58f47588641fd6019f36f", + "@esbuild/linux-loong64/bin/esbuild": "55a66f9854d6798f36b2b5471db74f2e552481887ea14d8bda1634a512383a43", + "@esbuild/linux-mips64el/bin/esbuild": "6bf7921a3af4a801051e056d85c360fe24bb446f488ef3da25f0b8e5cf973db1", + "@esbuild/linux-ppc64/bin/esbuild": "c30df60d09bb0ba4853d7b06e244ce966890d61ce60cadd9b22335f6379c316a", + "@esbuild/linux-riscv64/bin/esbuild": "36bdcdc8230eef385838cdfeb0d9a1565cbe4b9ace30097a511d77e894de36a1", + "@esbuild/linux-s390x/bin/esbuild": "bbbc1f92a76a5ca6e2976065222e42b02797363a1f119490dda315f74047741f", + "@esbuild/linux-x64/bin/esbuild": "e1698a3d5c6c0798fee4fd3b5cc816651f460c63d390a7a26ea4beb0b1884100", + "@esbuild/netbsd-arm64/bin/esbuild": "62548519d7ae875d060aa8c94bfb8ed38ef191671a5173d9f626bdb6b7516970", + "@esbuild/netbsd-x64/bin/esbuild": "f9d0e59d2b404559e3a0c958164d96960ebf0e04583b878b1d64d8f1c3698fcc", + "@esbuild/openbsd-arm64/bin/esbuild": "e10c45a0b62456632da41df058d7626b2e7cfe710780a2dc7f9f84681753f3aa", + "@esbuild/openbsd-x64/bin/esbuild": "720bbe607736716f2ecd37962436c5589d801966e868a2ae4e0e7e62d1e4e887", + "@esbuild/sunos-x64/bin/esbuild": "01a3bd9183631ca749f34d15601ea21ba6834614184c5c859f99d54bd683203d", + "@esbuild/win32-arm64/esbuild.exe": "530fb3933af14eefe85dfd06502f826e6ef60fdf4e75228ea67c696db312ecb1", + "@esbuild/win32-ia32/esbuild.exe": "b2e62af5c17e00939583be0a0762fdc469f352869a617edc91371b00454c76f0", + "@esbuild/win32-x64/esbuild.exe": "c7bee37877d0aa6a046e52783fa0a2cf1a9ce5579d68bb3083bda99d4bff18ef" + } } diff --git a/static/node_modules/udn-frontend/README.md b/static/node_modules/udn-frontend/README.md index 307d9ff..e149e72 100644 --- a/static/node_modules/udn-frontend/README.md +++ b/static/node_modules/udn-frontend/README.md @@ -59,4 +59,16 @@ UDN.requestMailbox(); ## 1.0.6 - add error handling with `connect()` -- add `onmailboxdelete` listener \ No newline at end of file +- add `onmailboxdelete` listener + +## 1.0.7 + +- add `uuid` property to Message + +## 1.0.8 + +- fix bug where messages would be considered sent even if the WebSocket is not ready + +## 1.0.9 + +- send confirmation to server that a message was received, necessary for mailboxes to function safely \ No newline at end of file diff --git a/static/node_modules/udn-frontend/index.ts b/static/node_modules/udn-frontend/index.ts index 8bf88cf..b48707e 100644 --- a/static/node_modules/udn-frontend/index.ts +++ b/static/node_modules/udn-frontend/index.ts @@ -1,4 +1,6 @@ export interface Message { + uuid?: string; // to be assigned by + // connecting to server requestingServerConnection?: boolean; @@ -15,21 +17,24 @@ export interface Message { unsubscribeChannel?: string; subscribed?: boolean; // sent by server - //sending message + // sending message messageChannel?: string; messageBody?: string; + + // confirming message + confirmingMessageReceived?: boolean; } export default class UDNFrontend { ws: WebSocket | undefined; // HANDLERS - private connectionHandler = () => {}; - private disconnectionHandler = () => {}; - private messageHandler = (data: Message) => {}; - private mailboxHandler = (mailboxId: string) => {}; - private mailboxConnectionHandler = (mailboxId: string) => {}; - private mailboxDeleteHandler = (mailboxId: string) => {}; + private connectionHandler = () => { }; + private disconnectionHandler = () => { }; + private messageHandler = (data: Message) => { }; + private mailboxHandler = (mailboxId: string) => { }; + private mailboxConnectionHandler = (mailboxId: string) => { }; + private mailboxDeleteHandler = (mailboxId: string) => { }; // INIT set onconnect(handler: () => void) { @@ -54,6 +59,7 @@ export default class UDNFrontend { // UTILITY METHODS private send(messageObject: Message): boolean { if (this.ws == undefined) return false; + if (this.ws.readyState != 1) return false; const messageString = JSON.stringify(messageObject); this.ws.send(messageString); @@ -80,6 +86,7 @@ export default class UDNFrontend { } else if (data.deletedMailbox) { return this.mailboxDeleteHandler(data.deletedMailbox); } else { + this.send({ uuid: data.uuid, confirmingMessageReceived: true }); this.messageHandler(data); } }); diff --git a/static/node_modules/udn-frontend/package.json b/static/node_modules/udn-frontend/package.json index 2e2d9e7..0d2d289 100644 --- a/static/node_modules/udn-frontend/package.json +++ b/static/node_modules/udn-frontend/package.json @@ -1,6 +1,6 @@ { "name": "udn-frontend", - "version": "1.0.6", + "version": "1.0.9", "description": "TypeScript library for UDN apps", "main": "index.ts", "scripts": { diff --git a/static/node_modules/uuid/CHANGELOG.md b/static/node_modules/uuid/CHANGELOG.md deleted file mode 100644 index f0ba9e1..0000000 --- a/static/node_modules/uuid/CHANGELOG.md +++ /dev/null @@ -1,292 +0,0 @@ -# Changelog - -All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines. - -## [10.0.0](https://github.com/uuidjs/uuid/compare/v9.0.0...v10.0.0) (2024-06-07) - -### ⚠ BREAKING CHANGES - -- update node support (drop node@12, node@14, add node@20) (#750) - -### Features - -- support support rfc9562 MAX uuid (new in RFC9562) ([#714](https://github.com/uuidjs/uuid/issues/714)) ([0385cd3](https://github.com/uuidjs/uuid/commit/0385cd3f18ae9920678b2849932fa7a9d9aee7d0)) -- support rfc9562 v6 uuids ([#754](https://github.com/uuidjs/uuid/issues/754)) ([c4ed13e](https://github.com/uuidjs/uuid/commit/c4ed13e7159d87c9e42a349bdd9dc955f1af46b6)) -- support rfc9562 v7 uuids ([#681](https://github.com/uuidjs/uuid/issues/681)) ([db76a12](https://github.com/uuidjs/uuid/commit/db76a1284760c441438f50a57924b322dae08891)) -- update node support matrix (only support node 16-20) ([#750](https://github.com/uuidjs/uuid/issues/750)) ([883b163](https://github.com/uuidjs/uuid/commit/883b163b9ab9d6655bfbd8a35e61a3c71674dfe1)) -- support rfc9562 v8 uuids ([#759](https://github.com/uuidjs/uuid/issues/759)) ([35a5342](https://github.com/uuidjs/uuid/commit/35a53428202657e402e6b4aa68f56c08194541bf)) - -### Bug Fixes - -- revert "perf: remove superfluous call to toLowerCase ([#677](https://github.com/uuidjs/uuid/issues/677))" ([#738](https://github.com/uuidjs/uuid/issues/738)) ([e267b90](https://github.com/uuidjs/uuid/commit/e267b9073df1d0ce119ee53c0487fe76acb2be37)) - -## [9.0.1](https://github.com/uuidjs/uuid/compare/v9.0.0...v9.0.1) (2023-09-12) - -### build - -- Fix CI to work with Node.js 20.x - -## [9.0.0](https://github.com/uuidjs/uuid/compare/v8.3.2...v9.0.0) (2022-09-05) - -### ⚠ BREAKING CHANGES - -- Drop Node.js 10.x support. This library always aims at supporting one EOLed LTS release which by this time now is 12.x which has reached EOL 30 Apr 2022. - -- Remove the minified UMD build from the package. - - Minified code is hard to audit and since this is a widely used library it seems more appropriate nowadays to optimize for auditability than to ship a legacy module format that, at best, serves educational purposes nowadays. - - For production browser use cases, users should be using a bundler. For educational purposes, today's online sandboxes like replit.com offer convenient ways to load npm modules, so the use case for UMD through repos like UNPKG or jsDelivr has largely vanished. - -- Drop IE 11 and Safari 10 support. Drop support for browsers that don't correctly implement const/let and default arguments, and no longer transpile the browser build to ES2015. - - This also removes the fallback on msCrypto instead of the crypto API. - - Browser tests are run in the first supported version of each supported browser and in the latest (as of this commit) version available on Browserstack. - -### Features - -- optimize uuid.v1 by 1.3x uuid.v4 by 4.3x (430%) ([#597](https://github.com/uuidjs/uuid/issues/597)) ([3a033f6](https://github.com/uuidjs/uuid/commit/3a033f6bab6bb3780ece6d645b902548043280bc)) -- remove UMD build ([#645](https://github.com/uuidjs/uuid/issues/645)) ([e948a0f](https://github.com/uuidjs/uuid/commit/e948a0f22bf22f4619b27bd913885e478e20fe6f)), closes [#620](https://github.com/uuidjs/uuid/issues/620) -- use native crypto.randomUUID when available ([#600](https://github.com/uuidjs/uuid/issues/600)) ([c9e076c](https://github.com/uuidjs/uuid/commit/c9e076c852edad7e9a06baaa1d148cf4eda6c6c4)) - -### Bug Fixes - -- add Jest/jsdom compatibility ([#642](https://github.com/uuidjs/uuid/issues/642)) ([16f9c46](https://github.com/uuidjs/uuid/commit/16f9c469edf46f0786164cdf4dc980743984a6fd)) -- change default export to named function ([#545](https://github.com/uuidjs/uuid/issues/545)) ([c57bc5a](https://github.com/uuidjs/uuid/commit/c57bc5a9a0653273aa639cda9177ce52efabe42a)) -- handle error when parameter is not set in v3 and v5 ([#622](https://github.com/uuidjs/uuid/issues/622)) ([fcd7388](https://github.com/uuidjs/uuid/commit/fcd73881692d9fabb63872576ba28e30ff852091)) -- run npm audit fix ([#644](https://github.com/uuidjs/uuid/issues/644)) ([04686f5](https://github.com/uuidjs/uuid/commit/04686f54c5fed2cfffc1b619f4970c4bb8532353)) -- upgrading from uuid3 broken link ([#568](https://github.com/uuidjs/uuid/issues/568)) ([1c849da](https://github.com/uuidjs/uuid/commit/1c849da6e164259e72e18636726345b13a7eddd6)) - -### build - -- drop Node.js 8.x from babel transpile target ([#603](https://github.com/uuidjs/uuid/issues/603)) ([aa11485](https://github.com/uuidjs/uuid/commit/aa114858260402107ec8a1e1a825dea0a259bcb5)) -- drop support for legacy browsers (IE11, Safari 10) ([#604](https://github.com/uuidjs/uuid/issues/604)) ([0f433e5](https://github.com/uuidjs/uuid/commit/0f433e5ec444edacd53016de67db021102f36148)) - -- drop node 10.x to upgrade dev dependencies ([#653](https://github.com/uuidjs/uuid/issues/653)) ([28a5712](https://github.com/uuidjs/uuid/commit/28a571283f8abda6b9d85e689f95b7d3ee9e282e)), closes [#643](https://github.com/uuidjs/uuid/issues/643) - -### [8.3.2](https://github.com/uuidjs/uuid/compare/v8.3.1...v8.3.2) (2020-12-08) - -### Bug Fixes - -- lazy load getRandomValues ([#537](https://github.com/uuidjs/uuid/issues/537)) ([16c8f6d](https://github.com/uuidjs/uuid/commit/16c8f6df2f6b09b4d6235602d6a591188320a82e)), closes [#536](https://github.com/uuidjs/uuid/issues/536) - -### [8.3.1](https://github.com/uuidjs/uuid/compare/v8.3.0...v8.3.1) (2020-10-04) - -### Bug Fixes - -- support expo>=39.0.0 ([#515](https://github.com/uuidjs/uuid/issues/515)) ([c65a0f3](https://github.com/uuidjs/uuid/commit/c65a0f3fa73b901959d638d1e3591dfacdbed867)), closes [#375](https://github.com/uuidjs/uuid/issues/375) - -## [8.3.0](https://github.com/uuidjs/uuid/compare/v8.2.0...v8.3.0) (2020-07-27) - -### Features - -- add parse/stringify/validate/version/NIL APIs ([#479](https://github.com/uuidjs/uuid/issues/479)) ([0e6c10b](https://github.com/uuidjs/uuid/commit/0e6c10ba1bf9517796ff23c052fc0468eedfd5f4)), closes [#475](https://github.com/uuidjs/uuid/issues/475) [#478](https://github.com/uuidjs/uuid/issues/478) [#480](https://github.com/uuidjs/uuid/issues/480) [#481](https://github.com/uuidjs/uuid/issues/481) [#180](https://github.com/uuidjs/uuid/issues/180) - -## [8.2.0](https://github.com/uuidjs/uuid/compare/v8.1.0...v8.2.0) (2020-06-23) - -### Features - -- improve performance of v1 string representation ([#453](https://github.com/uuidjs/uuid/issues/453)) ([0ee0b67](https://github.com/uuidjs/uuid/commit/0ee0b67c37846529c66089880414d29f3ae132d5)) -- remove deprecated v4 string parameter ([#454](https://github.com/uuidjs/uuid/issues/454)) ([88ce3ca](https://github.com/uuidjs/uuid/commit/88ce3ca0ba046f60856de62c7ce03f7ba98ba46c)), closes [#437](https://github.com/uuidjs/uuid/issues/437) -- support jspm ([#473](https://github.com/uuidjs/uuid/issues/473)) ([e9f2587](https://github.com/uuidjs/uuid/commit/e9f2587a92575cac31bc1d4ae944e17c09756659)) - -### Bug Fixes - -- prepare package exports for webpack 5 ([#468](https://github.com/uuidjs/uuid/issues/468)) ([8d6e6a5](https://github.com/uuidjs/uuid/commit/8d6e6a5f8965ca9575eb4d92e99a43435f4a58a8)) - -## [8.1.0](https://github.com/uuidjs/uuid/compare/v8.0.0...v8.1.0) (2020-05-20) - -### Features - -- improve v4 performance by reusing random number array ([#435](https://github.com/uuidjs/uuid/issues/435)) ([bf4af0d](https://github.com/uuidjs/uuid/commit/bf4af0d711b4d2ed03d1f74fd12ad0baa87dc79d)) -- optimize V8 performance of bytesToUuid ([#434](https://github.com/uuidjs/uuid/issues/434)) ([e156415](https://github.com/uuidjs/uuid/commit/e156415448ec1af2351fa0b6660cfb22581971f2)) - -### Bug Fixes - -- export package.json required by react-native and bundlers ([#449](https://github.com/uuidjs/uuid/issues/449)) ([be1c8fe](https://github.com/uuidjs/uuid/commit/be1c8fe9a3206c358e0059b52fafd7213aa48a52)), closes [ai/nanoevents#44](https://github.com/ai/nanoevents/issues/44#issuecomment-602010343) [#444](https://github.com/uuidjs/uuid/issues/444) - -## [8.0.0](https://github.com/uuidjs/uuid/compare/v7.0.3...v8.0.0) (2020-04-29) - -### ⚠ BREAKING CHANGES - -- For native ECMAScript Module (ESM) usage in Node.js only named exports are exposed, there is no more default export. - - ```diff - -import uuid from 'uuid'; - -console.log(uuid.v4()); // -> 'cd6c3b08-0adc-4f4b-a6ef-36087a1c9869' - +import { v4 as uuidv4 } from 'uuid'; - +uuidv4(); // ⇨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d' - ``` - -- Deep requiring specific algorithms of this library like `require('uuid/v4')`, which has been deprecated in `uuid@7`, is no longer supported. - - Instead use the named exports that this module exports. - - For ECMAScript Modules (ESM): - - ```diff - -import uuidv4 from 'uuid/v4'; - +import { v4 as uuidv4 } from 'uuid'; - uuidv4(); - ``` - - For CommonJS: - - ```diff - -const uuidv4 = require('uuid/v4'); - +const { v4: uuidv4 } = require('uuid'); - uuidv4(); - ``` - -### Features - -- native Node.js ES Modules (wrapper approach) ([#423](https://github.com/uuidjs/uuid/issues/423)) ([2d9f590](https://github.com/uuidjs/uuid/commit/2d9f590ad9701d692625c07ed62f0a0f91227991)), closes [#245](https://github.com/uuidjs/uuid/issues/245) [#419](https://github.com/uuidjs/uuid/issues/419) [#342](https://github.com/uuidjs/uuid/issues/342) -- remove deep requires ([#426](https://github.com/uuidjs/uuid/issues/426)) ([daf72b8](https://github.com/uuidjs/uuid/commit/daf72b84ceb20272a81bb5fbddb05dd95922cbba)) - -### Bug Fixes - -- add CommonJS syntax example to README quickstart section ([#417](https://github.com/uuidjs/uuid/issues/417)) ([e0ec840](https://github.com/uuidjs/uuid/commit/e0ec8402c7ad44b7ef0453036c612f5db513fda0)) - -### [7.0.3](https://github.com/uuidjs/uuid/compare/v7.0.2...v7.0.3) (2020-03-31) - -### Bug Fixes - -- make deep require deprecation warning work in browsers ([#409](https://github.com/uuidjs/uuid/issues/409)) ([4b71107](https://github.com/uuidjs/uuid/commit/4b71107d8c0d2ef56861ede6403fc9dc35a1e6bf)), closes [#408](https://github.com/uuidjs/uuid/issues/408) - -### [7.0.2](https://github.com/uuidjs/uuid/compare/v7.0.1...v7.0.2) (2020-03-04) - -### Bug Fixes - -- make access to msCrypto consistent ([#393](https://github.com/uuidjs/uuid/issues/393)) ([8bf2a20](https://github.com/uuidjs/uuid/commit/8bf2a20f3565df743da7215eebdbada9d2df118c)) -- simplify link in deprecation warning ([#391](https://github.com/uuidjs/uuid/issues/391)) ([bb2c8e4](https://github.com/uuidjs/uuid/commit/bb2c8e4e9f4c5f9c1eaaf3ea59710c633cd90cb7)) -- update links to match content in readme ([#386](https://github.com/uuidjs/uuid/issues/386)) ([44f2f86](https://github.com/uuidjs/uuid/commit/44f2f86e9d2bbf14ee5f0f00f72a3db1292666d4)) - -### [7.0.1](https://github.com/uuidjs/uuid/compare/v7.0.0...v7.0.1) (2020-02-25) - -### Bug Fixes - -- clean up esm builds for node and browser ([#383](https://github.com/uuidjs/uuid/issues/383)) ([59e6a49](https://github.com/uuidjs/uuid/commit/59e6a49e7ce7b3e8fb0f3ee52b9daae72af467dc)) -- provide browser versions independent from module system ([#380](https://github.com/uuidjs/uuid/issues/380)) ([4344a22](https://github.com/uuidjs/uuid/commit/4344a22e7aed33be8627eeaaf05360f256a21753)), closes [#378](https://github.com/uuidjs/uuid/issues/378) - -## [7.0.0](https://github.com/uuidjs/uuid/compare/v3.4.0...v7.0.0) (2020-02-24) - -### ⚠ BREAKING CHANGES - -- The default export, which used to be the v4() method but which was already discouraged in v3.x of this library, has been removed. -- Explicitly note that deep imports of the different uuid version functions are deprecated and no longer encouraged and that ECMAScript module named imports should be used instead. Emit a deprecation warning for people who deep-require the different algorithm variants. -- Remove builtin support for insecure random number generators in the browser. Users who want that will have to supply their own random number generator function. -- Remove support for generating v3 and v5 UUIDs in Node.js<4.x -- Convert code base to ECMAScript Modules (ESM) and release CommonJS build for node and ESM build for browser bundlers. - -### Features - -- add UMD build to npm package ([#357](https://github.com/uuidjs/uuid/issues/357)) ([4e75adf](https://github.com/uuidjs/uuid/commit/4e75adf435196f28e3fbbe0185d654b5ded7ca2c)), closes [#345](https://github.com/uuidjs/uuid/issues/345) -- add various es module and CommonJS examples ([b238510](https://github.com/uuidjs/uuid/commit/b238510bf352463521f74bab175a3af9b7a42555)) -- ensure that docs are up-to-date in CI ([ee5e77d](https://github.com/uuidjs/uuid/commit/ee5e77db547474f5a8f23d6c857a6d399209986b)) -- hybrid CommonJS & ECMAScript modules build ([a3f078f](https://github.com/uuidjs/uuid/commit/a3f078faa0baff69ab41aed08e041f8f9c8993d0)) -- remove insecure fallback random number generator ([3a5842b](https://github.com/uuidjs/uuid/commit/3a5842b141a6e5de0ae338f391661e6b84b167c9)), closes [#173](https://github.com/uuidjs/uuid/issues/173) -- remove support for pre Node.js v4 Buffer API ([#356](https://github.com/uuidjs/uuid/issues/356)) ([b59b5c5](https://github.com/uuidjs/uuid/commit/b59b5c5ecad271c5453f1a156f011671f6d35627)) -- rename repository to github:uuidjs/uuid ([#351](https://github.com/uuidjs/uuid/issues/351)) ([c37a518](https://github.com/uuidjs/uuid/commit/c37a518e367ac4b6d0aa62dba1bc6ce9e85020f7)), closes [#338](https://github.com/uuidjs/uuid/issues/338) - -### Bug Fixes - -- add deep-require proxies for local testing and adjust tests ([#365](https://github.com/uuidjs/uuid/issues/365)) ([7fedc79](https://github.com/uuidjs/uuid/commit/7fedc79ac8fda4bfd1c566c7f05ef4ac13b2db48)) -- add note about removal of default export ([#372](https://github.com/uuidjs/uuid/issues/372)) ([12749b7](https://github.com/uuidjs/uuid/commit/12749b700eb49db8a9759fd306d8be05dbfbd58c)), closes [#370](https://github.com/uuidjs/uuid/issues/370) -- deprecated deep requiring of the different algorithm versions ([#361](https://github.com/uuidjs/uuid/issues/361)) ([c0bdf15](https://github.com/uuidjs/uuid/commit/c0bdf15e417639b1aeb0b247b2fb11f7a0a26b23)) - -## [3.4.0](https://github.com/uuidjs/uuid/compare/v3.3.3...v3.4.0) (2020-01-16) - -### Features - -- rename repository to github:uuidjs/uuid ([#351](https://github.com/uuidjs/uuid/issues/351)) ([e2d7314](https://github.com/uuidjs/uuid/commit/e2d7314)), closes [#338](https://github.com/uuidjs/uuid/issues/338) - -## [3.3.3](https://github.com/uuidjs/uuid/compare/v3.3.2...v3.3.3) (2019-08-19) - -### Bug Fixes - -- no longer run ci tests on node v4 -- upgrade dependencies - -## [3.3.2](https://github.com/uuidjs/uuid/compare/v3.3.1...v3.3.2) (2018-06-28) - -### Bug Fixes - -- typo ([305d877](https://github.com/uuidjs/uuid/commit/305d877)) - -## [3.3.1](https://github.com/uuidjs/uuid/compare/v3.3.0...v3.3.1) (2018-06-28) - -### Bug Fixes - -- fix [#284](https://github.com/uuidjs/uuid/issues/284) by setting function name in try-catch ([f2a60f2](https://github.com/uuidjs/uuid/commit/f2a60f2)) - -# [3.3.0](https://github.com/uuidjs/uuid/compare/v3.2.1...v3.3.0) (2018-06-22) - -### Bug Fixes - -- assignment to readonly property to allow running in strict mode ([#270](https://github.com/uuidjs/uuid/issues/270)) ([d062fdc](https://github.com/uuidjs/uuid/commit/d062fdc)) -- fix [#229](https://github.com/uuidjs/uuid/issues/229) ([c9684d4](https://github.com/uuidjs/uuid/commit/c9684d4)) -- Get correct version of IE11 crypto ([#274](https://github.com/uuidjs/uuid/issues/274)) ([153d331](https://github.com/uuidjs/uuid/commit/153d331)) -- mem issue when generating uuid ([#267](https://github.com/uuidjs/uuid/issues/267)) ([c47702c](https://github.com/uuidjs/uuid/commit/c47702c)) - -### Features - -- enforce Conventional Commit style commit messages ([#282](https://github.com/uuidjs/uuid/issues/282)) ([cc9a182](https://github.com/uuidjs/uuid/commit/cc9a182)) - -## [3.2.1](https://github.com/uuidjs/uuid/compare/v3.2.0...v3.2.1) (2018-01-16) - -### Bug Fixes - -- use msCrypto if available. Fixes [#241](https://github.com/uuidjs/uuid/issues/241) ([#247](https://github.com/uuidjs/uuid/issues/247)) ([1fef18b](https://github.com/uuidjs/uuid/commit/1fef18b)) - -# [3.2.0](https://github.com/uuidjs/uuid/compare/v3.1.0...v3.2.0) (2018-01-16) - -### Bug Fixes - -- remove mistakenly added typescript dependency, rollback version (standard-version will auto-increment) ([09fa824](https://github.com/uuidjs/uuid/commit/09fa824)) -- use msCrypto if available. Fixes [#241](https://github.com/uuidjs/uuid/issues/241) ([#247](https://github.com/uuidjs/uuid/issues/247)) ([1fef18b](https://github.com/uuidjs/uuid/commit/1fef18b)) - -### Features - -- Add v3 Support ([#217](https://github.com/uuidjs/uuid/issues/217)) ([d94f726](https://github.com/uuidjs/uuid/commit/d94f726)) - -# [3.1.0](https://github.com/uuidjs/uuid/compare/v3.1.0...v3.0.1) (2017-06-17) - -### Bug Fixes - -- (fix) Add .npmignore file to exclude test/ and other non-essential files from packing. (#183) -- Fix typo (#178) -- Simple typo fix (#165) - -### Features - -- v5 support in CLI (#197) -- V5 support (#188) - -# 3.0.1 (2016-11-28) - -- split uuid versions into separate files - -# 3.0.0 (2016-11-17) - -- remove .parse and .unparse - -# 2.0.0 - -- Removed uuid.BufferClass - -# 1.4.0 - -- Improved module context detection -- Removed public RNG functions - -# 1.3.2 - -- Improve tests and handling of v1() options (Issue #24) -- Expose RNG option to allow for perf testing with different generators - -# 1.3.0 - -- Support for version 1 ids, thanks to [@ctavan](https://github.com/ctavan)! -- Support for node.js crypto API -- De-emphasizing performance in favor of a) cryptographic quality PRNGs where available and b) more manageable code diff --git a/static/node_modules/uuid/CONTRIBUTING.md b/static/node_modules/uuid/CONTRIBUTING.md deleted file mode 100644 index 4a4503d..0000000 --- a/static/node_modules/uuid/CONTRIBUTING.md +++ /dev/null @@ -1,18 +0,0 @@ -# Contributing - -Please feel free to file GitHub Issues or propose Pull Requests. We're always happy to discuss improvements to this library! - -## Testing - -```shell -npm test -``` - -## Releasing - -Releases are supposed to be done from master, version bumping is automated through [`standard-version`](https://github.com/conventional-changelog/standard-version): - -```shell -npm run release -- --dry-run # verify output manually -npm run release # follow the instructions from the output of this command -``` diff --git a/static/node_modules/uuid/README.md b/static/node_modules/uuid/README.md index b9079b6..9bd966a 100644 --- a/static/node_modules/uuid/README.md +++ b/static/node_modules/uuid/README.md @@ -2,54 +2,41 @@ -- This file is auto-generated from README_js.md. Changes should be made there. --> +# uuid [![CI](https://github.com/uuidjs/uuid/workflows/CI/badge.svg)](https://github.com/uuidjs/uuid/actions?query=workflow%3ACI) [![Browser](https://github.com/uuidjs/uuid/workflows/Browser/badge.svg)](https://github.com/uuidjs/uuid/actions/workflows/browser.yml) -# uuid [![CI](https://github.com/uuidjs/uuid/workflows/CI/badge.svg)](https://github.com/uuidjs/uuid/actions?query=workflow%3ACI) [![Browser](https://github.com/uuidjs/uuid/workflows/Browser/badge.svg)](https://github.com/uuidjs/uuid/actions?query=workflow%3ABrowser) +For the creation of [RFC9562](https://www.rfc-editor.org/rfc/rfc9562.html) (formerly [RFC4122](https://www.rfc-editor.org/rfc/rfc4122.html)) UUIDs -For the creation of [RFC9562](https://www.rfc-editor.org/rfc/rfc9562.html) (formally [RFC4122](https://www.rfc-editor.org/rfc/rfc4122.html)) UUIDs - -- **Complete** - Support for all RFC9562 (nee RFC4122) UUID versions -- **Cross-platform** - Support for ... - - CommonJS, [ECMAScript Modules](#ecmascript-modules) and [CDN builds](#cdn-builds) - - NodeJS 16+ ([LTS releases](https://github.com/nodejs/Release)) - - Chrome, Safari, Firefox, Edge browsers - - Webpack and rollup.js module bundlers +- **Complete** - Support for all RFC9562 UUID versions +- **Cross-platform** - Support for... + - [Typescript](#support) + - [Chrome, Safari, Firefox, and Edge](#support) + - [NodeJS](#support) - [React Native / Expo](#react-native--expo) -- **Secure** - Cryptographically-strong random values -- **Small** - Zero-dependency, small footprint, plays nice with "tree shaking" packagers -- **CLI** - Includes the [`uuid` command line](#command-line) utility +- **Secure** - Uses modern `crypto` API for random values +- **Compact** - Zero-dependency, [tree-shakable](https://developer.mozilla.org/en-US/docs/Glossary/Tree_shaking) +- **CLI** - [`uuid` command line](#command-line) utility > [!NOTE] -> Upgrading from `uuid@3`? Your code is probably okay, but check out [Upgrading From `uuid@3`](#upgrading-from-uuid3) for details. - - -> [!NOTE] -> Only interested in creating a version 4 UUID? You might be able to use [`crypto.randomUUID()`](https://developer.mozilla.org/en-US/docs/Web/API/Crypto/randomUUID), eliminating the need to install this library. +> +> Starting with `uuid@12` CommonJS is no longer supported. See [implications](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c) and [motivation](https://github.com/uuidjs/uuid/issues/881) for details. ## Quickstart -To create a random UUID... - **1. Install** ```shell npm install uuid ``` -**2. Create a UUID** (ES6 module syntax) +**2. Create a UUID** ```javascript import { v4 as uuidv4 } from 'uuid'; + uuidv4(); // ⇨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d' ``` -... or using CommonJS syntax: - -```javascript -const { v4: uuidv4 } = require('uuid'); -uuidv4(); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed' -``` - For timestamp UUIDs, namespace UUIDs, and other options read on ... ## API Summary @@ -118,16 +105,13 @@ Example: import { parse as uuidParse } from 'uuid'; // Parse a UUID -const bytes = uuidParse('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); - -// Convert to hex strings to show byte order (for documentation purposes) -[...bytes].map((v) => v.toString(16).padStart(2, '0')); // ⇨ - // [ - // '6e', 'c0', 'bd', '7f', - // '11', 'c0', '43', 'da', - // '97', '5e', '2a', '8a', - // 'd9', 'eb', 'ae', '0b' - // ] +uuidParse('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨ +// Uint8Array(16) [ +// 110, 192, 189, 127, 17, +// 192, 67, 218, 151, 94, +// 42, 138, 217, 235, 174, +// 11 +// ] ``` ### uuid.stringify(arr[, offset]) @@ -150,9 +134,24 @@ Example: ```javascript import { stringify as uuidStringify } from 'uuid'; -const uuidBytes = [ - 0x6e, 0xc0, 0xbd, 0x7f, 0x11, 0xc0, 0x43, 0xda, 0x97, 0x5e, 0x2a, 0x8a, 0xd9, 0xeb, 0xae, 0x0b, -]; +const uuidBytes = Uint8Array.of( + 0x6e, + 0xc0, + 0xbd, + 0x7f, + 0x11, + 0xc0, + 0x43, + 0xda, + 0x97, + 0x5e, + 0x2a, + 0x8a, + 0xd9, + 0xeb, + 0xae, + 0x0b +); uuidStringify(uuidBytes); // ⇨ '6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b' ``` @@ -164,13 +163,13 @@ Create an RFC version 1 (timestamp) UUID | | | | --- | --- | | [`options`] | `Object` with one or more of the following properties: | -| [`options.node` ] | RFC "node" field as an `Array[6]` of byte values (per 4.1.6) | -| [`options.clockseq`] | RFC "clock sequence" as a `Number` between 0 - 0x3fff | -| [`options.msecs`] | RFC "timestamp" field (`Number` of milliseconds, unix epoch) | -| [`options.nsecs`] | RFC "timestamp" field (`Number` of nanoseconds to add to `msecs`, should be 0-10,000) | -| [`options.random`] | `Array` of 16 random bytes (0-255) | +| [`options.node = (random)` ] | RFC "node" field as an `Array[6]` of byte values (per 4.1.6) | +| [`options.clockseq = (random)`] | RFC "clock sequence" as a `Number` between 0 - 0x3fff | +| [`options.msecs = (current time)`] | RFC "timestamp" field (`Number` of milliseconds, unix epoch) | +| [`options.nsecs = 0`] | RFC "timestamp" field (`Number` of nanoseconds to add to `msecs`, should be 0-10,000) | +| [`options.random = (random)`] | `Array` of 16 random bytes (0-255) used to generate other fields, above | | [`options.rng`] | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255) | -| [`buffer`] | `Array \| Buffer` If specified, uuid will be written here in byte-form, starting at `offset` | +| [`buffer`] | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` | | [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` | | _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` | | _throws_ | `Error` if more than 10M UUIDs/sec are requested | @@ -188,7 +187,7 @@ Example: ```javascript import { v1 as uuidv1 } from 'uuid'; -uuidv1(); // ⇨ '2c5ea4c0-4067-11e9-8bad-9b1deb4d3b7d' +uuidv1(); // ⇨ '2c5ea4c0-4067-11e9-9b5d-ab8dfbbd4bed' ``` Example using `options`: @@ -197,7 +196,7 @@ Example using `options`: import { v1 as uuidv1 } from 'uuid'; const options = { - node: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab], + node: Uint8Array.of(0x01, 0x23, 0x45, 0x67, 0x89, 0xab), clockseq: 0x1234, msecs: new Date('2011-11-01').getTime(), nsecs: 5678, @@ -234,7 +233,7 @@ Create an RFC version 4 (random) UUID | [`options`] | `Object` with one or more of the following properties: | | [`options.random`] | `Array` of 16 random bytes (0-255) | | [`options.rng`] | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255) | -| [`buffer`] | `Array \| Buffer` If specified, uuid will be written here in byte-form, starting at `offset` | +| [`buffer`] | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` | | [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` | | _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` | @@ -252,9 +251,24 @@ Example using predefined `random` values: import { v4 as uuidv4 } from 'uuid'; const v4options = { - random: [ - 0x10, 0x91, 0x56, 0xbe, 0xc4, 0xfb, 0xc1, 0xea, 0x71, 0xb4, 0xef, 0xe1, 0x67, 0x1c, 0x58, 0x36, - ], + random: Uint8Array.of( + 0x10, + 0x91, + 0x56, + 0xbe, + 0xc4, + 0xfb, + 0xc1, + 0xea, + 0x71, + 0xb4, + 0xef, + 0xe1, + 0x67, + 0x1c, + 0x58, + 0x36 + ), }; uuidv4(v4options); // ⇨ '109156be-c4fb-41ea-b1b4-efe1671c5836' ``` @@ -267,7 +281,7 @@ Create an RFC version 5 (namespace w/ SHA-1) UUID | --- | --- | | `name` | `String \| Array` | | `namespace` | `String \| Array[16]` Namespace UUID | -| [`buffer`] | `Array \| Buffer` If specified, uuid will be written here in byte-form, starting at `offset` | +| [`buffer`] | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` | | [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` | | _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` | @@ -304,7 +318,7 @@ This method takes the same arguments as uuid.v1(). ```javascript import { v6 as uuidv6 } from 'uuid'; -uuidv6(); // ⇨ '1e940672-c5ea-64c0-8bad-9b1deb4d3b7d' +uuidv6(); // ⇨ '1e940672-c5ea-64c1-9bdd-2b0d7b3dcb6d' ``` Example using `options`: @@ -338,11 +352,11 @@ Create an RFC version 7 (random) UUID | | | | --- | --- | | [`options`] | `Object` with one or more of the following properties: | -| [`options.msecs`] | RFC "timestamp" field (`Number` of milliseconds, unix epoch) | -| [`options.random`] | `Array` of 16 random bytes (0-255) | +| [`options.msecs = (current time)`] | RFC "timestamp" field (`Number` of milliseconds, unix epoch) | +| [`options.random = (random)`] | `Array` of 16 random bytes (0-255) used to generate other fields, above | | [`options.rng`] | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255) | -| [`options.seq`] | 31 bit monotonic sequence counter as `Number` between 0 - 0x7fffffff | -| [`buffer`] | `Array \| Buffer` If specified, uuid will be written here in byte-form, starting at `offset` | +| [`options.seq = (random)`] | 32-bit sequence `Number` between 0 - 0xffffffff. This may be provided to help ensure uniqueness for UUIDs generated within the same millisecond time interval. Default = random value. | +| [`buffer`] | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` | | [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` | | _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` | @@ -351,7 +365,7 @@ Example: ```javascript import { v7 as uuidv7 } from 'uuid'; -uuidv7(); // ⇨ '01695553-c90c-722d-9b5d-b38dfbbd4bed' +uuidv7(); // ⇨ '01695553-c90c-745a-b76f-770d7b3dcb6d' ``` ### ~~uuid.v8()~~ @@ -447,54 +461,30 @@ Note: may be "URL" or "DNS" to use the corresponding UUIDs defined by RFC9562 ``` -## ECMAScript Modules +## `options` Handling for Timestamp UUIDs -This library comes with [ECMAScript Modules](https://www.ecma-international.org/ecma-262/6.0/#sec-modules) (ESM) support for Node.js versions that support it ([example](./examples/node-esmodules/)) as well as bundlers like [rollup.js](https://rollupjs.org/guide/en/#tree-shaking) ([example](./examples/browser-rollup/)) and [webpack](https://webpack.js.org/guides/tree-shaking/) ([example](./examples/browser-webpack/)) (targeting both, Node.js and browser environments). +Prior to `uuid@11`, it was possible for `options` state to interfere with the internal state used to ensure uniqueness of timestamp-based UUIDs (the `v1()`, `v6()`, and `v7()` methods). Starting with `uuid@11`, this issue has been addressed by using the presence of the `options` argument as a flag to select between two possible behaviors: -```javascript -import { v4 as uuidv4 } from 'uuid'; -uuidv4(); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed' -``` +- Without `options`: Internal state is utilized to improve UUID uniqueness. +- With `options`: Internal state is **NOT** used and, instead, appropriate defaults are applied as needed. -To run the examples you must first create a dist build of this library in the module root: +## Support -```shell -npm run build -``` +**Browsers**: `uuid` [builds are tested](/uuidjs/uuid/blob/main/wdio.conf.js) against the latest version of desktop Chrome, Safari, Firefox, and Edge. Mobile versions of these same browsers are expected to work but aren't currently tested. -## CDN Builds +**Node**: `uuid` [builds are tested](https://github.com/uuidjs/uuid/blob/main/.github/workflows/ci.yml#L26-L27) against node ([LTS releases](https://github.com/nodejs/Release)), plus one prior. E.g. At the time of this writing `node@20` is the "maintenance" release and `node@24` is the "current" release, so `uuid` supports `node@18`-`node@24`. -### ECMAScript Modules - -To load this module directly into modern browsers that [support loading ECMAScript Modules](https://caniuse.com/#feat=es6-module) you can make use of [jspm](https://jspm.org/): - -```html - -``` - -### UMD - -As of `uuid@9` [UMD (Universal Module Definition)](https://github.com/umdjs/umd) builds are no longer shipped with this library. - -If you need a UMD build of this library, use a bundler like Webpack or Rollup. Alternatively, refer to the documentation of [`uuid@8.3.2`](https://github.com/uuidjs/uuid/blob/v8.3.2/README.md#umd) which was the last version that shipped UMD builds. +**Typescript**: TS versions released within the past two years are supported. [source](https://github.com/microsoft/TypeScript/issues/49088#issuecomment-2468723715) ## Known issues -### Duplicate UUIDs (Googlebot) - -This module may generate duplicate UUIDs when run in clients with _deterministic_ random number generators, such as [Googlebot crawlers](https://developers.google.com/search/docs/advanced/crawling/overview-google-crawlers). This can cause problems for apps that expect client-generated UUIDs to always be unique. Developers should be prepared for this and have a strategy for dealing with possible collisions, such as: - -- Check for duplicate UUIDs, fail gracefully -- Disable write operations for Googlebot clients + ### "getRandomValues() not supported" This error occurs in environments where the standard [`crypto.getRandomValues()`](https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues) API is not supported. This issue can be resolved by adding an appropriate polyfill: -### React Native / Expo +#### React Native / Expo 1. Install [`react-native-get-random-values`](https://github.com/LinusU/react-native-get-random-values#readme) 1. Import it _before_ `uuid`. Since `uuid` might also appear as a transitive dependency of some other imports it's safest to just import `react-native-get-random-values` as the very first thing in your entry point: @@ -504,81 +494,6 @@ import 'react-native-get-random-values'; import { v4 as uuidv4 } from 'uuid'; ``` - -> [!NOTE] -> If you are using Expo, you must be using at least `react-native-get-random-values@1.5.0` and `expo@39.0.0`. - -### Web Workers / Service Workers (Edge <= 18) - -[In Edge <= 18, Web Crypto is not supported in Web Workers or Service Workers](https://caniuse.com/#feat=cryptography) and we are not aware of a polyfill (let us know if you find one, please). - -### IE 11 (Internet Explorer) - -Support for IE11 and other legacy browsers has been dropped as of `uuid@9`. If you need to support legacy browsers, you can always transpile the uuid module source yourself (e.g. using [Babel](https://babeljs.io/)). - -## Upgrading From `uuid@7` - -### Only Named Exports Supported When Using with Node.js ESM - -`uuid@7` did not come with native ECMAScript Module (ESM) support for Node.js. Importing it in Node.js ESM consequently imported the CommonJS source with a default export. This library now comes with true Node.js ESM support and only provides named exports. - -Instead of doing: - -```javascript -import uuid from 'uuid'; -uuid.v4(); -``` - -you will now have to use the named exports: - -```javascript -import { v4 as uuidv4 } from 'uuid'; -uuidv4(); -``` - -### Deep Requires No Longer Supported - -Deep requires like `require('uuid/v4')` [which have been deprecated in `uuid@7`](#deep-requires-now-deprecated) are no longer supported. - -## Upgrading From `uuid@3` - -"_Wait... what happened to `uuid@4` thru `uuid@6`?!?_" - -In order to avoid confusion with RFC [version 4](#uuidv4options-buffer-offset) and [version 5](#uuidv5name-namespace-buffer-offset) UUIDs, and a possible [version 6](http://gh.peabody.io/uuidv6/), releases 4 thru 6 of this module have been skipped. - -### Deep Requires Now Deprecated - -`uuid@3` encouraged the use of deep requires to minimize the bundle size of browser builds: - -```javascript -const uuidv4 = require('uuid/v4'); // <== NOW DEPRECATED! -uuidv4(); -``` - -As of `uuid@7` this library now provides ECMAScript modules builds, which allow packagers like Webpack and Rollup to do "tree-shaking" to remove dead code. Instead, use the `import` syntax: - -```javascript -import { v4 as uuidv4 } from 'uuid'; -uuidv4(); -``` - -... or for CommonJS: - -```javascript -const { v4: uuidv4 } = require('uuid'); -uuidv4(); -``` - -### Default Export Removed - -`uuid@3` was exporting the Version 4 UUID method as a default export: - -```javascript -const uuid = require('uuid'); // <== REMOVED! -``` - -This usage pattern was already discouraged in `uuid@3` and has been removed in `uuid@7`. - --- -Markdown generated from [README_js.md](README_js.md) by +Markdown generated from [README_js.md](README_js.md) by diff --git a/static/node_modules/uuid/dist/bin/uuid b/static/node_modules/uuid/dist/bin/uuid deleted file mode 100755 index f38d2ee..0000000 --- a/static/node_modules/uuid/dist/bin/uuid +++ /dev/null @@ -1,2 +0,0 @@ -#!/usr/bin/env node -require('../uuid-bin'); diff --git a/static/node_modules/uuid/dist/commonjs-browser/index.js b/static/node_modules/uuid/dist/commonjs-browser/index.js deleted file mode 100644 index 3e909f4..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/index.js +++ /dev/null @@ -1,104 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -Object.defineProperty(exports, "MAX", { - enumerable: true, - get: function get() { - return _max.default; - } -}); -Object.defineProperty(exports, "NIL", { - enumerable: true, - get: function get() { - return _nil.default; - } -}); -Object.defineProperty(exports, "parse", { - enumerable: true, - get: function get() { - return _parse.default; - } -}); -Object.defineProperty(exports, "stringify", { - enumerable: true, - get: function get() { - return _stringify.default; - } -}); -Object.defineProperty(exports, "v1", { - enumerable: true, - get: function get() { - return _v.default; - } -}); -Object.defineProperty(exports, "v1ToV6", { - enumerable: true, - get: function get() { - return _v1ToV.default; - } -}); -Object.defineProperty(exports, "v3", { - enumerable: true, - get: function get() { - return _v2.default; - } -}); -Object.defineProperty(exports, "v4", { - enumerable: true, - get: function get() { - return _v3.default; - } -}); -Object.defineProperty(exports, "v5", { - enumerable: true, - get: function get() { - return _v4.default; - } -}); -Object.defineProperty(exports, "v6", { - enumerable: true, - get: function get() { - return _v5.default; - } -}); -Object.defineProperty(exports, "v6ToV1", { - enumerable: true, - get: function get() { - return _v6ToV.default; - } -}); -Object.defineProperty(exports, "v7", { - enumerable: true, - get: function get() { - return _v6.default; - } -}); -Object.defineProperty(exports, "validate", { - enumerable: true, - get: function get() { - return _validate.default; - } -}); -Object.defineProperty(exports, "version", { - enumerable: true, - get: function get() { - return _version.default; - } -}); -var _max = _interopRequireDefault(require("./max.js")); -var _nil = _interopRequireDefault(require("./nil.js")); -var _parse = _interopRequireDefault(require("./parse.js")); -var _stringify = _interopRequireDefault(require("./stringify.js")); -var _v = _interopRequireDefault(require("./v1.js")); -var _v1ToV = _interopRequireDefault(require("./v1ToV6.js")); -var _v2 = _interopRequireDefault(require("./v3.js")); -var _v3 = _interopRequireDefault(require("./v4.js")); -var _v4 = _interopRequireDefault(require("./v5.js")); -var _v5 = _interopRequireDefault(require("./v6.js")); -var _v6ToV = _interopRequireDefault(require("./v6ToV1.js")); -var _v6 = _interopRequireDefault(require("./v7.js")); -var _validate = _interopRequireDefault(require("./validate.js")); -var _version = _interopRequireDefault(require("./version.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/max.js b/static/node_modules/uuid/dist/commonjs-browser/max.js deleted file mode 100644 index 8de76f8..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/max.js +++ /dev/null @@ -1,7 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _default = exports.default = 'ffffffff-ffff-ffff-ffff-ffffffffffff'; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/md5.js b/static/node_modules/uuid/dist/commonjs-browser/md5.js deleted file mode 100644 index a3bf60d..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/md5.js +++ /dev/null @@ -1,200 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -/* - * Browser-compatible JavaScript MD5 - * - * Modification of JavaScript MD5 - * https://github.com/blueimp/JavaScript-MD5 - * - * Copyright 2011, Sebastian Tschan - * https://blueimp.net - * - * Licensed under the MIT license: - * https://opensource.org/licenses/MIT - * - * Based on - * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message - * Digest Algorithm, as defined in RFC 1321. - * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009 - * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet - * Distributed under the BSD License - * See http://pajhome.org.uk/crypt/md5 for more info. - */ -function md5(bytes) { - if (typeof bytes === 'string') { - var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape - - bytes = new Uint8Array(msg.length); - for (var i = 0; i < msg.length; ++i) { - bytes[i] = msg.charCodeAt(i); - } - } - return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8)); -} - -/* - * Convert an array of little-endian words to an array of bytes - */ -function md5ToHexEncodedArray(input) { - var output = []; - var length32 = input.length * 32; - var hexTab = '0123456789abcdef'; - for (var i = 0; i < length32; i += 8) { - var x = input[i >> 5] >>> i % 32 & 0xff; - var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16); - output.push(hex); - } - return output; -} - -/** - * Calculate output length with padding and bit length - */ -function getOutputLength(inputLength8) { - return (inputLength8 + 64 >>> 9 << 4) + 14 + 1; -} - -/* - * Calculate the MD5 of an array of little-endian words, and a bit length. - */ -function wordsToMd5(x, len) { - /* append padding */ - x[len >> 5] |= 0x80 << len % 32; - x[getOutputLength(len) - 1] = len; - var a = 1732584193; - var b = -271733879; - var c = -1732584194; - var d = 271733878; - for (var i = 0; i < x.length; i += 16) { - var olda = a; - var oldb = b; - var oldc = c; - var oldd = d; - a = md5ff(a, b, c, d, x[i], 7, -680876936); - d = md5ff(d, a, b, c, x[i + 1], 12, -389564586); - c = md5ff(c, d, a, b, x[i + 2], 17, 606105819); - b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330); - a = md5ff(a, b, c, d, x[i + 4], 7, -176418897); - d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426); - c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341); - b = md5ff(b, c, d, a, x[i + 7], 22, -45705983); - a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416); - d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417); - c = md5ff(c, d, a, b, x[i + 10], 17, -42063); - b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162); - a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682); - d = md5ff(d, a, b, c, x[i + 13], 12, -40341101); - c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290); - b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329); - a = md5gg(a, b, c, d, x[i + 1], 5, -165796510); - d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632); - c = md5gg(c, d, a, b, x[i + 11], 14, 643717713); - b = md5gg(b, c, d, a, x[i], 20, -373897302); - a = md5gg(a, b, c, d, x[i + 5], 5, -701558691); - d = md5gg(d, a, b, c, x[i + 10], 9, 38016083); - c = md5gg(c, d, a, b, x[i + 15], 14, -660478335); - b = md5gg(b, c, d, a, x[i + 4], 20, -405537848); - a = md5gg(a, b, c, d, x[i + 9], 5, 568446438); - d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690); - c = md5gg(c, d, a, b, x[i + 3], 14, -187363961); - b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501); - a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467); - d = md5gg(d, a, b, c, x[i + 2], 9, -51403784); - c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473); - b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734); - a = md5hh(a, b, c, d, x[i + 5], 4, -378558); - d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463); - c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562); - b = md5hh(b, c, d, a, x[i + 14], 23, -35309556); - a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060); - d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353); - c = md5hh(c, d, a, b, x[i + 7], 16, -155497632); - b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640); - a = md5hh(a, b, c, d, x[i + 13], 4, 681279174); - d = md5hh(d, a, b, c, x[i], 11, -358537222); - c = md5hh(c, d, a, b, x[i + 3], 16, -722521979); - b = md5hh(b, c, d, a, x[i + 6], 23, 76029189); - a = md5hh(a, b, c, d, x[i + 9], 4, -640364487); - d = md5hh(d, a, b, c, x[i + 12], 11, -421815835); - c = md5hh(c, d, a, b, x[i + 15], 16, 530742520); - b = md5hh(b, c, d, a, x[i + 2], 23, -995338651); - a = md5ii(a, b, c, d, x[i], 6, -198630844); - d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415); - c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905); - b = md5ii(b, c, d, a, x[i + 5], 21, -57434055); - a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571); - d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606); - c = md5ii(c, d, a, b, x[i + 10], 15, -1051523); - b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799); - a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359); - d = md5ii(d, a, b, c, x[i + 15], 10, -30611744); - c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380); - b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649); - a = md5ii(a, b, c, d, x[i + 4], 6, -145523070); - d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379); - c = md5ii(c, d, a, b, x[i + 2], 15, 718787259); - b = md5ii(b, c, d, a, x[i + 9], 21, -343485551); - a = safeAdd(a, olda); - b = safeAdd(b, oldb); - c = safeAdd(c, oldc); - d = safeAdd(d, oldd); - } - return [a, b, c, d]; -} - -/* - * Convert an array bytes to an array of little-endian words - * Characters >255 have their high-byte silently ignored. - */ -function bytesToWords(input) { - if (input.length === 0) { - return []; - } - var length8 = input.length * 8; - var output = new Uint32Array(getOutputLength(length8)); - for (var i = 0; i < length8; i += 8) { - output[i >> 5] |= (input[i / 8] & 0xff) << i % 32; - } - return output; -} - -/* - * Add integers, wrapping at 2^32. This uses 16-bit operations internally - * to work around bugs in some JS interpreters. - */ -function safeAdd(x, y) { - var lsw = (x & 0xffff) + (y & 0xffff); - var msw = (x >> 16) + (y >> 16) + (lsw >> 16); - return msw << 16 | lsw & 0xffff; -} - -/* - * Bitwise rotate a 32-bit number to the left. - */ -function bitRotateLeft(num, cnt) { - return num << cnt | num >>> 32 - cnt; -} - -/* - * These functions implement the four basic operations the algorithm uses. - */ -function md5cmn(q, a, b, x, s, t) { - return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b); -} -function md5ff(a, b, c, d, x, s, t) { - return md5cmn(b & c | ~b & d, a, b, x, s, t); -} -function md5gg(a, b, c, d, x, s, t) { - return md5cmn(b & d | c & ~d, a, b, x, s, t); -} -function md5hh(a, b, c, d, x, s, t) { - return md5cmn(b ^ c ^ d, a, b, x, s, t); -} -function md5ii(a, b, c, d, x, s, t) { - return md5cmn(c ^ (b | ~d), a, b, x, s, t); -} -var _default = exports.default = md5; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/native.js b/static/node_modules/uuid/dist/commonjs-browser/native.js deleted file mode 100644 index b48d539..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/native.js +++ /dev/null @@ -1,10 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto); -var _default = exports.default = { - randomUUID -}; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/nil.js b/static/node_modules/uuid/dist/commonjs-browser/nil.js deleted file mode 100644 index f7967e9..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/nil.js +++ /dev/null @@ -1,7 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _default = exports.default = '00000000-0000-0000-0000-000000000000'; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/parse.js b/static/node_modules/uuid/dist/commonjs-browser/parse.js deleted file mode 100644 index 8ba8f50..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/parse.js +++ /dev/null @@ -1,44 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _validate = _interopRequireDefault(require("./validate.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -function parse(uuid) { - if (!(0, _validate.default)(uuid)) { - throw TypeError('Invalid UUID'); - } - var v; - var arr = new Uint8Array(16); - - // Parse ########-....-....-....-............ - arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24; - arr[1] = v >>> 16 & 0xff; - arr[2] = v >>> 8 & 0xff; - arr[3] = v & 0xff; - - // Parse ........-####-....-....-............ - arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8; - arr[5] = v & 0xff; - - // Parse ........-....-####-....-............ - arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8; - arr[7] = v & 0xff; - - // Parse ........-....-....-####-............ - arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8; - arr[9] = v & 0xff; - - // Parse ........-....-....-....-############ - // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes) - arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff; - arr[11] = v / 0x100000000 & 0xff; - arr[12] = v >>> 24 & 0xff; - arr[13] = v >>> 16 & 0xff; - arr[14] = v >>> 8 & 0xff; - arr[15] = v & 0xff; - return arr; -} -var _default = exports.default = parse; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/regex.js b/static/node_modules/uuid/dist/commonjs-browser/regex.js deleted file mode 100644 index fc02a88..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/regex.js +++ /dev/null @@ -1,7 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _default = exports.default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/rng.js b/static/node_modules/uuid/dist/commonjs-browser/rng.js deleted file mode 100644 index 6cf7e98..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/rng.js +++ /dev/null @@ -1,23 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = rng; -// Unique ID creation requires a high quality random # generator. In the browser we therefore -// require the crypto API and do not support built-in fallback to lower quality random number -// generators (like Math.random()). - -var getRandomValues; -var rnds8 = new Uint8Array(16); -function rng() { - // lazy load so that environments that need to polyfill have a chance to do so - if (!getRandomValues) { - // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. - getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto); - if (!getRandomValues) { - throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported'); - } - } - return getRandomValues(rnds8); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/sha1.js b/static/node_modules/uuid/dist/commonjs-browser/sha1.js deleted file mode 100644 index ae1cf63..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/sha1.js +++ /dev/null @@ -1,82 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -// Adapted from Chris Veness' SHA1 code at -// http://www.movable-type.co.uk/scripts/sha1.html -function f(s, x, y, z) { - switch (s) { - case 0: - return x & y ^ ~x & z; - case 1: - return x ^ y ^ z; - case 2: - return x & y ^ x & z ^ y & z; - case 3: - return x ^ y ^ z; - } -} -function ROTL(x, n) { - return x << n | x >>> 32 - n; -} -function sha1(bytes) { - var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6]; - var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]; - if (typeof bytes === 'string') { - var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape - - bytes = []; - for (var i = 0; i < msg.length; ++i) { - bytes.push(msg.charCodeAt(i)); - } - } else if (!Array.isArray(bytes)) { - // Convert Array-like to Array - bytes = Array.prototype.slice.call(bytes); - } - bytes.push(0x80); - var l = bytes.length / 4 + 2; - var N = Math.ceil(l / 16); - var M = new Array(N); - for (var _i = 0; _i < N; ++_i) { - var arr = new Uint32Array(16); - for (var j = 0; j < 16; ++j) { - arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3]; - } - M[_i] = arr; - } - M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32); - M[N - 1][14] = Math.floor(M[N - 1][14]); - M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff; - for (var _i2 = 0; _i2 < N; ++_i2) { - var W = new Uint32Array(80); - for (var t = 0; t < 16; ++t) { - W[t] = M[_i2][t]; - } - for (var _t = 16; _t < 80; ++_t) { - W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1); - } - var a = H[0]; - var b = H[1]; - var c = H[2]; - var d = H[3]; - var e = H[4]; - for (var _t2 = 0; _t2 < 80; ++_t2) { - var s = Math.floor(_t2 / 20); - var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0; - e = d; - d = c; - c = ROTL(b, 30) >>> 0; - b = a; - a = T; - } - H[0] = H[0] + a >>> 0; - H[1] = H[1] + b >>> 0; - H[2] = H[2] + c >>> 0; - H[3] = H[3] + d >>> 0; - H[4] = H[4] + e >>> 0; - } - return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff]; -} -var _default = exports.default = sha1; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/stringify.js b/static/node_modules/uuid/dist/commonjs-browser/stringify.js deleted file mode 100644 index 92dec9e..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/stringify.js +++ /dev/null @@ -1,38 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -exports.unsafeStringify = unsafeStringify; -var _validate = _interopRequireDefault(require("./validate.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -/** - * Convert array of 16 byte values to UUID string format of the form: - * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX - */ -var byteToHex = []; -for (var i = 0; i < 256; ++i) { - byteToHex.push((i + 0x100).toString(16).slice(1)); -} -function unsafeStringify(arr, offset = 0) { - // Note: Be careful editing this code! It's been tuned for performance - // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 - // - // Note to future-self: No, you can't remove the `toLowerCase()` call. - // REF: https://github.com/uuidjs/uuid/pull/677#issuecomment-1757351351 - return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); -} -function stringify(arr, offset = 0) { - var uuid = unsafeStringify(arr, offset); - // Consistency check for valid UUID. If this throws, it's likely due to one - // of the following: - // - One or more input array values don't map to a hex octet (leading to - // "undefined" in the uuid) - // - Invalid input values for the RFC `version` or `variant` fields - if (!(0, _validate.default)(uuid)) { - throw TypeError('Stringified UUID is invalid'); - } - return uuid; -} -var _default = exports.default = stringify; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/v1.js b/static/node_modules/uuid/dist/commonjs-browser/v1.js deleted file mode 100644 index 9789251..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/v1.js +++ /dev/null @@ -1,131 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _rng = _interopRequireDefault(require("./rng.js")); -var _stringify = require("./stringify.js"); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -// **`v1()` - Generate time-based UUID** -// -// Inspired by https://github.com/LiosK/UUID.js -// and http://docs.python.org/library/uuid.html - -var _nodeId; -var _clockseq; - -// Previous uuid creation time -var _lastMSecs = 0; -var _lastNSecs = 0; - -// See https://github.com/uuidjs/uuid for API details -function v1(options, buf, offset) { - var i = buf && offset || 0; - var b = buf || new Array(16); - options = options || {}; - var node = options.node; - var clockseq = options.clockseq; - - // v1 only: Use cached `node` and `clockseq` values - if (!options._v6) { - if (!node) { - node = _nodeId; - } - if (clockseq == null) { - clockseq = _clockseq; - } - } - - // Handle cases where we need entropy. We do this lazily to minimize issues - // related to insufficient system entropy. See #189 - if (node == null || clockseq == null) { - var seedBytes = options.random || (options.rng || _rng.default)(); - - // Randomize node - if (node == null) { - node = [seedBytes[0], seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]]; - - // v1 only: cache node value for reuse - if (!_nodeId && !options._v6) { - // per RFC4122 4.5: Set MAC multicast bit (v1 only) - node[0] |= 0x01; // Set multicast bit - - _nodeId = node; - } - } - - // Randomize clockseq - if (clockseq == null) { - // Per 4.2.2, randomize (14 bit) clockseq - clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; - if (_clockseq === undefined && !options._v6) { - _clockseq = clockseq; - } - } - } - - // v1 & v6 timestamps are 100 nano-second units since the Gregorian epoch, - // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so time is - // handled internally as 'msecs' (integer milliseconds) and 'nsecs' - // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. - var msecs = options.msecs !== undefined ? options.msecs : Date.now(); - - // Per 4.2.1.2, use count of uuid's generated during the current clock - // cycle to simulate higher resolution clock - var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; - - // Time since last uuid creation (in msecs) - var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; - - // Per 4.2.1.2, Bump clockseq on clock regression - if (dt < 0 && options.clockseq === undefined) { - clockseq = clockseq + 1 & 0x3fff; - } - - // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new - // time interval - if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { - nsecs = 0; - } - - // Per 4.2.1.2 Throw error if too many uuids are requested - if (nsecs >= 10000) { - throw new Error("uuid.v1(): Can't create more than 10M uuids/sec"); - } - _lastMSecs = msecs; - _lastNSecs = nsecs; - _clockseq = clockseq; - - // Per 4.1.4 - Convert from unix epoch to Gregorian epoch - msecs += 12219292800000; - - // `time_low` - var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; - b[i++] = tl >>> 24 & 0xff; - b[i++] = tl >>> 16 & 0xff; - b[i++] = tl >>> 8 & 0xff; - b[i++] = tl & 0xff; - - // `time_mid` - var tmh = msecs / 0x100000000 * 10000 & 0xfffffff; - b[i++] = tmh >>> 8 & 0xff; - b[i++] = tmh & 0xff; - - // `time_high_and_version` - b[i++] = tmh >>> 24 & 0xf | 0x10; // include version - b[i++] = tmh >>> 16 & 0xff; - - // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) - b[i++] = clockseq >>> 8 | 0x80; - - // `clock_seq_low` - b[i++] = clockseq & 0xff; - - // `node` - for (var n = 0; n < 6; ++n) { - b[i + n] = node[n]; - } - return buf || (0, _stringify.unsafeStringify)(b); -} -var _default = exports.default = v1; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/v1ToV6.js b/static/node_modules/uuid/dist/commonjs-browser/v1ToV6.js deleted file mode 100644 index 0b43199..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/v1ToV6.js +++ /dev/null @@ -1,26 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = v1ToV6; -var _parse = _interopRequireDefault(require("./parse.js")); -var _stringify = require("./stringify.js"); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -/** - * Convert a v1 UUID to a v6 UUID - * - * @param {string|Uint8Array} uuid - The v1 UUID to convert to v6 - * @returns {string|Uint8Array} The v6 UUID as the same type as the `uuid` arg - * (string or Uint8Array) - */ -function v1ToV6(uuid) { - var v1Bytes = typeof uuid === 'string' ? (0, _parse.default)(uuid) : uuid; - var v6Bytes = _v1ToV6(v1Bytes); - return typeof uuid === 'string' ? (0, _stringify.unsafeStringify)(v6Bytes) : v6Bytes; -} - -// Do the field transformation needed for v1 -> v6 -function _v1ToV6(v1Bytes, randomize = false) { - return Uint8Array.of((v1Bytes[6] & 0x0f) << 4 | v1Bytes[7] >> 4 & 0x0f, (v1Bytes[7] & 0x0f) << 4 | (v1Bytes[4] & 0xf0) >> 4, (v1Bytes[4] & 0x0f) << 4 | (v1Bytes[5] & 0xf0) >> 4, (v1Bytes[5] & 0x0f) << 4 | (v1Bytes[0] & 0xf0) >> 4, (v1Bytes[0] & 0x0f) << 4 | (v1Bytes[1] & 0xf0) >> 4, (v1Bytes[1] & 0x0f) << 4 | (v1Bytes[2] & 0xf0) >> 4, 0x60 | v1Bytes[2] & 0x0f, v1Bytes[3], v1Bytes[8], v1Bytes[9], v1Bytes[10], v1Bytes[11], v1Bytes[12], v1Bytes[13], v1Bytes[14], v1Bytes[15]); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/v3.js b/static/node_modules/uuid/dist/commonjs-browser/v3.js deleted file mode 100644 index 8761fc3..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/v3.js +++ /dev/null @@ -1,11 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _v = _interopRequireDefault(require("./v35.js")); -var _md = _interopRequireDefault(require("./md5.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -var v3 = (0, _v.default)('v3', 0x30, _md.default); -var _default = exports.default = v3; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/v35.js b/static/node_modules/uuid/dist/commonjs-browser/v35.js deleted file mode 100644 index c22c23c..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/v35.js +++ /dev/null @@ -1,63 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.URL = exports.DNS = void 0; -exports.default = v35; -var _stringify = require("./stringify.js"); -var _parse = _interopRequireDefault(require("./parse.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -function stringToBytes(str) { - str = unescape(encodeURIComponent(str)); // UTF8 escape - - var bytes = []; - for (var i = 0; i < str.length; ++i) { - bytes.push(str.charCodeAt(i)); - } - return bytes; -} -var DNS = exports.DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; -var URL = exports.URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; -function v35(name, version, hashfunc) { - function generateUUID(value, namespace, buf, offset) { - var _namespace; - if (typeof value === 'string') { - value = stringToBytes(value); - } - if (typeof namespace === 'string') { - namespace = (0, _parse.default)(namespace); - } - if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) { - throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)'); - } - - // Compute hash of namespace and value, Per 4.3 - // Future: Use spread syntax when supported on all platforms, e.g. `bytes = - // hashfunc([...namespace, ... value])` - var bytes = new Uint8Array(16 + value.length); - bytes.set(namespace); - bytes.set(value, namespace.length); - bytes = hashfunc(bytes); - bytes[6] = bytes[6] & 0x0f | version; - bytes[8] = bytes[8] & 0x3f | 0x80; - if (buf) { - offset = offset || 0; - for (var i = 0; i < 16; ++i) { - buf[offset + i] = bytes[i]; - } - return buf; - } - return (0, _stringify.unsafeStringify)(bytes); - } - - // Function#name is not settable on some platforms (#270) - try { - generateUUID.name = name; - } catch (err) {} - - // For CommonJS default export support - generateUUID.DNS = DNS; - generateUUID.URL = URL; - return generateUUID; -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/v4.js b/static/node_modules/uuid/dist/commonjs-browser/v4.js deleted file mode 100644 index 2242a3a..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/v4.js +++ /dev/null @@ -1,32 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _native = _interopRequireDefault(require("./native.js")); -var _rng = _interopRequireDefault(require("./rng.js")); -var _stringify = require("./stringify.js"); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -function v4(options, buf, offset) { - if (_native.default.randomUUID && !buf && !options) { - return _native.default.randomUUID(); - } - options = options || {}; - var rnds = options.random || (options.rng || _rng.default)(); - - // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` - rnds[6] = rnds[6] & 0x0f | 0x40; - rnds[8] = rnds[8] & 0x3f | 0x80; - - // Copy bytes to buffer, if provided - if (buf) { - offset = offset || 0; - for (var i = 0; i < 16; ++i) { - buf[offset + i] = rnds[i]; - } - return buf; - } - return (0, _stringify.unsafeStringify)(rnds); -} -var _default = exports.default = v4; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/v5.js b/static/node_modules/uuid/dist/commonjs-browser/v5.js deleted file mode 100644 index 54ad2cb..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/v5.js +++ /dev/null @@ -1,11 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _v = _interopRequireDefault(require("./v35.js")); -var _sha = _interopRequireDefault(require("./sha1.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -var v5 = (0, _v.default)('v5', 0x50, _sha.default); -var _default = exports.default = v5; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/v6.js b/static/node_modules/uuid/dist/commonjs-browser/v6.js deleted file mode 100644 index cc4ece9..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/v6.js +++ /dev/null @@ -1,42 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = v6; -var _stringify = require("./stringify.js"); -var _v = _interopRequireDefault(require("./v1.js")); -var _v1ToV = _interopRequireDefault(require("./v1ToV6.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; } -function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } -function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; } -function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } -function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } -/** - * - * @param {object} options - * @param {Uint8Array=} buf - * @param {number=} offset - * @returns - */ -function v6(options = {}, buf, offset = 0) { - // v6 is v1 with different field layout, so we start with a v1 UUID, albeit - // with slightly different behavior around how the clock_seq and node fields - // are randomized, which is why we call v1 with _v6: true. - var bytes = (0, _v.default)(_objectSpread(_objectSpread({}, options), {}, { - _v6: true - }), new Uint8Array(16)); - - // Reorder the fields to v6 layout. - bytes = (0, _v1ToV.default)(bytes); - - // Return as a byte array if requested - if (buf) { - for (var i = 0; i < 16; i++) { - buf[offset + i] = bytes[i]; - } - return buf; - } - return (0, _stringify.unsafeStringify)(bytes); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/v6ToV1.js b/static/node_modules/uuid/dist/commonjs-browser/v6ToV1.js deleted file mode 100644 index 3c8350a..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/v6ToV1.js +++ /dev/null @@ -1,26 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = v6ToV1; -var _parse = _interopRequireDefault(require("./parse.js")); -var _stringify = require("./stringify.js"); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -/** - * Convert a v6 UUID to a v1 UUID - * - * @param {string|Uint8Array} uuid - The v6 UUID to convert to v6 - * @returns {string|Uint8Array} The v1 UUID as the same type as the `uuid` arg - * (string or Uint8Array) - */ -function v6ToV1(uuid) { - var v6Bytes = typeof uuid === 'string' ? (0, _parse.default)(uuid) : uuid; - var v1Bytes = _v6ToV1(v6Bytes); - return typeof uuid === 'string' ? (0, _stringify.unsafeStringify)(v1Bytes) : v1Bytes; -} - -// Do the field transformation needed for v6 -> v1 -function _v6ToV1(v6Bytes) { - return Uint8Array.of((v6Bytes[3] & 0x0f) << 4 | v6Bytes[4] >> 4 & 0x0f, (v6Bytes[4] & 0x0f) << 4 | (v6Bytes[5] & 0xf0) >> 4, (v6Bytes[5] & 0x0f) << 4 | v6Bytes[6] & 0x0f, v6Bytes[7], (v6Bytes[1] & 0x0f) << 4 | (v6Bytes[2] & 0xf0) >> 4, (v6Bytes[2] & 0x0f) << 4 | (v6Bytes[3] & 0xf0) >> 4, 0x10 | (v6Bytes[0] & 0xf0) >> 4, (v6Bytes[0] & 0x0f) << 4 | (v6Bytes[1] & 0xf0) >> 4, v6Bytes[8], v6Bytes[9], v6Bytes[10], v6Bytes[11], v6Bytes[12], v6Bytes[13], v6Bytes[14], v6Bytes[15]); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/v7.js b/static/node_modules/uuid/dist/commonjs-browser/v7.js deleted file mode 100644 index 2e42801..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/v7.js +++ /dev/null @@ -1,152 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _rng = _interopRequireDefault(require("./rng.js")); -var _stringify = require("./stringify.js"); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -/** - * UUID V7 - Unix Epoch time-based UUID - * - * The IETF has published RFC9562, introducing 3 new UUID versions (6,7,8). This - * implementation of V7 is based on the accepted, though not yet approved, - * revisions. - * - * RFC 9562:https://www.rfc-editor.org/rfc/rfc9562.html Universally Unique - * IDentifiers (UUIDs) - - * - * Sample V7 value: - * https://www.rfc-editor.org/rfc/rfc9562.html#name-example-of-a-uuidv7-value - * - * Monotonic Bit Layout: RFC rfc9562.6.2 Method 1, Dedicated Counter Bits ref: - * https://www.rfc-editor.org/rfc/rfc9562.html#section-6.2-5.1 - * - * 0 1 2 3 0 1 2 3 4 5 6 - * 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * | unix_ts_ms | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * | unix_ts_ms | ver | seq_hi | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * |var| seq_low | rand | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * | rand | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * - * seq is a 31 bit serialized counter; comprised of 12 bit seq_hi and 19 bit - * seq_low, and randomly initialized upon timestamp change. 31 bit counter size - * was selected as any bitwise operations in node are done as _signed_ 32 bit - * ints. we exclude the sign bit. - */ - -var _seqLow = null; -var _seqHigh = null; -var _msecs = 0; -function v7(options, buf, offset) { - options = options || {}; - - // initialize buffer and pointer - var i = buf && offset || 0; - var b = buf || new Uint8Array(16); - - // rnds is Uint8Array(16) filled with random bytes - var rnds = options.random || (options.rng || _rng.default)(); - - // milliseconds since unix epoch, 1970-01-01 00:00 - var msecs = options.msecs !== undefined ? options.msecs : Date.now(); - - // seq is user provided 31 bit counter - var seq = options.seq !== undefined ? options.seq : null; - - // initialize local seq high/low parts - var seqHigh = _seqHigh; - var seqLow = _seqLow; - - // check if clock has advanced and user has not provided msecs - if (msecs > _msecs && options.msecs === undefined) { - _msecs = msecs; - - // unless user provided seq, reset seq parts - if (seq !== null) { - seqHigh = null; - seqLow = null; - } - } - - // if we have a user provided seq - if (seq !== null) { - // trim provided seq to 31 bits of value, avoiding overflow - if (seq > 0x7fffffff) { - seq = 0x7fffffff; - } - - // split provided seq into high/low parts - seqHigh = seq >>> 19 & 0xfff; - seqLow = seq & 0x7ffff; - } - - // randomly initialize seq - if (seqHigh === null || seqLow === null) { - seqHigh = rnds[6] & 0x7f; - seqHigh = seqHigh << 8 | rnds[7]; - seqLow = rnds[8] & 0x3f; // pad for var - seqLow = seqLow << 8 | rnds[9]; - seqLow = seqLow << 5 | rnds[10] >>> 3; - } - - // increment seq if within msecs window - if (msecs + 10000 > _msecs && seq === null) { - if (++seqLow > 0x7ffff) { - seqLow = 0; - if (++seqHigh > 0xfff) { - seqHigh = 0; - - // increment internal _msecs. this allows us to continue incrementing - // while staying monotonic. Note, once we hit 10k milliseconds beyond system - // clock, we will reset breaking monotonicity (after (2^31)*10000 generations) - _msecs++; - } - } - } else { - // resetting; we have advanced more than - // 10k milliseconds beyond system clock - _msecs = msecs; - } - _seqHigh = seqHigh; - _seqLow = seqLow; - - // [bytes 0-5] 48 bits of local timestamp - b[i++] = _msecs / 0x10000000000 & 0xff; - b[i++] = _msecs / 0x100000000 & 0xff; - b[i++] = _msecs / 0x1000000 & 0xff; - b[i++] = _msecs / 0x10000 & 0xff; - b[i++] = _msecs / 0x100 & 0xff; - b[i++] = _msecs & 0xff; - - // [byte 6] - set 4 bits of version (7) with first 4 bits seq_hi - b[i++] = seqHigh >>> 4 & 0x0f | 0x70; - - // [byte 7] remaining 8 bits of seq_hi - b[i++] = seqHigh & 0xff; - - // [byte 8] - variant (2 bits), first 6 bits seq_low - b[i++] = seqLow >>> 13 & 0x3f | 0x80; - - // [byte 9] 8 bits seq_low - b[i++] = seqLow >>> 5 & 0xff; - - // [byte 10] remaining 5 bits seq_low, 3 bits random - b[i++] = seqLow << 3 & 0xff | rnds[10] & 0x07; - - // [bytes 11-15] always random - b[i++] = rnds[11]; - b[i++] = rnds[12]; - b[i++] = rnds[13]; - b[i++] = rnds[14]; - b[i++] = rnds[15]; - return buf || (0, _stringify.unsafeStringify)(b); -} -var _default = exports.default = v7; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/validate.js b/static/node_modules/uuid/dist/commonjs-browser/validate.js deleted file mode 100644 index d47181a..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/validate.js +++ /dev/null @@ -1,12 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _regex = _interopRequireDefault(require("./regex.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -function validate(uuid) { - return typeof uuid === 'string' && _regex.default.test(uuid); -} -var _default = exports.default = validate; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/commonjs-browser/version.js b/static/node_modules/uuid/dist/commonjs-browser/version.js deleted file mode 100644 index 0c6bbdd..0000000 --- a/static/node_modules/uuid/dist/commonjs-browser/version.js +++ /dev/null @@ -1,15 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _validate = _interopRequireDefault(require("./validate.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -function version(uuid) { - if (!(0, _validate.default)(uuid)) { - throw TypeError('Invalid UUID'); - } - return parseInt(uuid.slice(14, 15), 16); -} -var _default = exports.default = version; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/index.js b/static/node_modules/uuid/dist/esm-browser/index.js deleted file mode 100644 index 45214b3..0000000 --- a/static/node_modules/uuid/dist/esm-browser/index.js +++ /dev/null @@ -1,14 +0,0 @@ -export { default as MAX } from './max.js'; -export { default as NIL } from './nil.js'; -export { default as parse } from './parse.js'; -export { default as stringify } from './stringify.js'; -export { default as v1 } from './v1.js'; -export { default as v1ToV6 } from './v1ToV6.js'; -export { default as v3 } from './v3.js'; -export { default as v4 } from './v4.js'; -export { default as v5 } from './v5.js'; -export { default as v6 } from './v6.js'; -export { default as v6ToV1 } from './v6ToV1.js'; -export { default as v7 } from './v7.js'; -export { default as validate } from './validate.js'; -export { default as version } from './version.js'; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/max.js b/static/node_modules/uuid/dist/esm-browser/max.js deleted file mode 100644 index f46a281..0000000 --- a/static/node_modules/uuid/dist/esm-browser/max.js +++ /dev/null @@ -1 +0,0 @@ -export default 'ffffffff-ffff-ffff-ffff-ffffffffffff'; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/md5.js b/static/node_modules/uuid/dist/esm-browser/md5.js deleted file mode 100644 index 82d170e..0000000 --- a/static/node_modules/uuid/dist/esm-browser/md5.js +++ /dev/null @@ -1,194 +0,0 @@ -/* - * Browser-compatible JavaScript MD5 - * - * Modification of JavaScript MD5 - * https://github.com/blueimp/JavaScript-MD5 - * - * Copyright 2011, Sebastian Tschan - * https://blueimp.net - * - * Licensed under the MIT license: - * https://opensource.org/licenses/MIT - * - * Based on - * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message - * Digest Algorithm, as defined in RFC 1321. - * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009 - * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet - * Distributed under the BSD License - * See http://pajhome.org.uk/crypt/md5 for more info. - */ -function md5(bytes) { - if (typeof bytes === 'string') { - var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape - - bytes = new Uint8Array(msg.length); - for (var i = 0; i < msg.length; ++i) { - bytes[i] = msg.charCodeAt(i); - } - } - return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8)); -} - -/* - * Convert an array of little-endian words to an array of bytes - */ -function md5ToHexEncodedArray(input) { - var output = []; - var length32 = input.length * 32; - var hexTab = '0123456789abcdef'; - for (var i = 0; i < length32; i += 8) { - var x = input[i >> 5] >>> i % 32 & 0xff; - var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16); - output.push(hex); - } - return output; -} - -/** - * Calculate output length with padding and bit length - */ -function getOutputLength(inputLength8) { - return (inputLength8 + 64 >>> 9 << 4) + 14 + 1; -} - -/* - * Calculate the MD5 of an array of little-endian words, and a bit length. - */ -function wordsToMd5(x, len) { - /* append padding */ - x[len >> 5] |= 0x80 << len % 32; - x[getOutputLength(len) - 1] = len; - var a = 1732584193; - var b = -271733879; - var c = -1732584194; - var d = 271733878; - for (var i = 0; i < x.length; i += 16) { - var olda = a; - var oldb = b; - var oldc = c; - var oldd = d; - a = md5ff(a, b, c, d, x[i], 7, -680876936); - d = md5ff(d, a, b, c, x[i + 1], 12, -389564586); - c = md5ff(c, d, a, b, x[i + 2], 17, 606105819); - b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330); - a = md5ff(a, b, c, d, x[i + 4], 7, -176418897); - d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426); - c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341); - b = md5ff(b, c, d, a, x[i + 7], 22, -45705983); - a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416); - d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417); - c = md5ff(c, d, a, b, x[i + 10], 17, -42063); - b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162); - a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682); - d = md5ff(d, a, b, c, x[i + 13], 12, -40341101); - c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290); - b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329); - a = md5gg(a, b, c, d, x[i + 1], 5, -165796510); - d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632); - c = md5gg(c, d, a, b, x[i + 11], 14, 643717713); - b = md5gg(b, c, d, a, x[i], 20, -373897302); - a = md5gg(a, b, c, d, x[i + 5], 5, -701558691); - d = md5gg(d, a, b, c, x[i + 10], 9, 38016083); - c = md5gg(c, d, a, b, x[i + 15], 14, -660478335); - b = md5gg(b, c, d, a, x[i + 4], 20, -405537848); - a = md5gg(a, b, c, d, x[i + 9], 5, 568446438); - d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690); - c = md5gg(c, d, a, b, x[i + 3], 14, -187363961); - b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501); - a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467); - d = md5gg(d, a, b, c, x[i + 2], 9, -51403784); - c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473); - b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734); - a = md5hh(a, b, c, d, x[i + 5], 4, -378558); - d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463); - c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562); - b = md5hh(b, c, d, a, x[i + 14], 23, -35309556); - a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060); - d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353); - c = md5hh(c, d, a, b, x[i + 7], 16, -155497632); - b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640); - a = md5hh(a, b, c, d, x[i + 13], 4, 681279174); - d = md5hh(d, a, b, c, x[i], 11, -358537222); - c = md5hh(c, d, a, b, x[i + 3], 16, -722521979); - b = md5hh(b, c, d, a, x[i + 6], 23, 76029189); - a = md5hh(a, b, c, d, x[i + 9], 4, -640364487); - d = md5hh(d, a, b, c, x[i + 12], 11, -421815835); - c = md5hh(c, d, a, b, x[i + 15], 16, 530742520); - b = md5hh(b, c, d, a, x[i + 2], 23, -995338651); - a = md5ii(a, b, c, d, x[i], 6, -198630844); - d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415); - c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905); - b = md5ii(b, c, d, a, x[i + 5], 21, -57434055); - a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571); - d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606); - c = md5ii(c, d, a, b, x[i + 10], 15, -1051523); - b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799); - a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359); - d = md5ii(d, a, b, c, x[i + 15], 10, -30611744); - c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380); - b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649); - a = md5ii(a, b, c, d, x[i + 4], 6, -145523070); - d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379); - c = md5ii(c, d, a, b, x[i + 2], 15, 718787259); - b = md5ii(b, c, d, a, x[i + 9], 21, -343485551); - a = safeAdd(a, olda); - b = safeAdd(b, oldb); - c = safeAdd(c, oldc); - d = safeAdd(d, oldd); - } - return [a, b, c, d]; -} - -/* - * Convert an array bytes to an array of little-endian words - * Characters >255 have their high-byte silently ignored. - */ -function bytesToWords(input) { - if (input.length === 0) { - return []; - } - var length8 = input.length * 8; - var output = new Uint32Array(getOutputLength(length8)); - for (var i = 0; i < length8; i += 8) { - output[i >> 5] |= (input[i / 8] & 0xff) << i % 32; - } - return output; -} - -/* - * Add integers, wrapping at 2^32. This uses 16-bit operations internally - * to work around bugs in some JS interpreters. - */ -function safeAdd(x, y) { - var lsw = (x & 0xffff) + (y & 0xffff); - var msw = (x >> 16) + (y >> 16) + (lsw >> 16); - return msw << 16 | lsw & 0xffff; -} - -/* - * Bitwise rotate a 32-bit number to the left. - */ -function bitRotateLeft(num, cnt) { - return num << cnt | num >>> 32 - cnt; -} - -/* - * These functions implement the four basic operations the algorithm uses. - */ -function md5cmn(q, a, b, x, s, t) { - return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b); -} -function md5ff(a, b, c, d, x, s, t) { - return md5cmn(b & c | ~b & d, a, b, x, s, t); -} -function md5gg(a, b, c, d, x, s, t) { - return md5cmn(b & d | c & ~d, a, b, x, s, t); -} -function md5hh(a, b, c, d, x, s, t) { - return md5cmn(b ^ c ^ d, a, b, x, s, t); -} -function md5ii(a, b, c, d, x, s, t) { - return md5cmn(c ^ (b | ~d), a, b, x, s, t); -} -export default md5; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/native.js b/static/node_modules/uuid/dist/esm-browser/native.js deleted file mode 100644 index ba09dec..0000000 --- a/static/node_modules/uuid/dist/esm-browser/native.js +++ /dev/null @@ -1,4 +0,0 @@ -var randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto); -export default { - randomUUID -}; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/nil.js b/static/node_modules/uuid/dist/esm-browser/nil.js deleted file mode 100644 index b36324c..0000000 --- a/static/node_modules/uuid/dist/esm-browser/nil.js +++ /dev/null @@ -1 +0,0 @@ -export default '00000000-0000-0000-0000-000000000000'; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/parse.js b/static/node_modules/uuid/dist/esm-browser/parse.js deleted file mode 100644 index 8758831..0000000 --- a/static/node_modules/uuid/dist/esm-browser/parse.js +++ /dev/null @@ -1,37 +0,0 @@ -import validate from './validate.js'; -function parse(uuid) { - if (!validate(uuid)) { - throw TypeError('Invalid UUID'); - } - var v; - var arr = new Uint8Array(16); - - // Parse ########-....-....-....-............ - arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24; - arr[1] = v >>> 16 & 0xff; - arr[2] = v >>> 8 & 0xff; - arr[3] = v & 0xff; - - // Parse ........-####-....-....-............ - arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8; - arr[5] = v & 0xff; - - // Parse ........-....-####-....-............ - arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8; - arr[7] = v & 0xff; - - // Parse ........-....-....-####-............ - arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8; - arr[9] = v & 0xff; - - // Parse ........-....-....-....-############ - // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes) - arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff; - arr[11] = v / 0x100000000 & 0xff; - arr[12] = v >>> 24 & 0xff; - arr[13] = v >>> 16 & 0xff; - arr[14] = v >>> 8 & 0xff; - arr[15] = v & 0xff; - return arr; -} -export default parse; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/regex.js b/static/node_modules/uuid/dist/esm-browser/regex.js deleted file mode 100644 index 848a1fe..0000000 --- a/static/node_modules/uuid/dist/esm-browser/regex.js +++ /dev/null @@ -1 +0,0 @@ -export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/rng.js b/static/node_modules/uuid/dist/esm-browser/rng.js deleted file mode 100644 index e54d388..0000000 --- a/static/node_modules/uuid/dist/esm-browser/rng.js +++ /dev/null @@ -1,17 +0,0 @@ -// Unique ID creation requires a high quality random # generator. In the browser we therefore -// require the crypto API and do not support built-in fallback to lower quality random number -// generators (like Math.random()). - -var getRandomValues; -var rnds8 = new Uint8Array(16); -export default function rng() { - // lazy load so that environments that need to polyfill have a chance to do so - if (!getRandomValues) { - // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. - getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto); - if (!getRandomValues) { - throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported'); - } - } - return getRandomValues(rnds8); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/sha1.js b/static/node_modules/uuid/dist/esm-browser/sha1.js deleted file mode 100644 index bd88311..0000000 --- a/static/node_modules/uuid/dist/esm-browser/sha1.js +++ /dev/null @@ -1,76 +0,0 @@ -// Adapted from Chris Veness' SHA1 code at -// http://www.movable-type.co.uk/scripts/sha1.html -function f(s, x, y, z) { - switch (s) { - case 0: - return x & y ^ ~x & z; - case 1: - return x ^ y ^ z; - case 2: - return x & y ^ x & z ^ y & z; - case 3: - return x ^ y ^ z; - } -} -function ROTL(x, n) { - return x << n | x >>> 32 - n; -} -function sha1(bytes) { - var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6]; - var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]; - if (typeof bytes === 'string') { - var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape - - bytes = []; - for (var i = 0; i < msg.length; ++i) { - bytes.push(msg.charCodeAt(i)); - } - } else if (!Array.isArray(bytes)) { - // Convert Array-like to Array - bytes = Array.prototype.slice.call(bytes); - } - bytes.push(0x80); - var l = bytes.length / 4 + 2; - var N = Math.ceil(l / 16); - var M = new Array(N); - for (var _i = 0; _i < N; ++_i) { - var arr = new Uint32Array(16); - for (var j = 0; j < 16; ++j) { - arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3]; - } - M[_i] = arr; - } - M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32); - M[N - 1][14] = Math.floor(M[N - 1][14]); - M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff; - for (var _i2 = 0; _i2 < N; ++_i2) { - var W = new Uint32Array(80); - for (var t = 0; t < 16; ++t) { - W[t] = M[_i2][t]; - } - for (var _t = 16; _t < 80; ++_t) { - W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1); - } - var a = H[0]; - var b = H[1]; - var c = H[2]; - var d = H[3]; - var e = H[4]; - for (var _t2 = 0; _t2 < 80; ++_t2) { - var s = Math.floor(_t2 / 20); - var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0; - e = d; - d = c; - c = ROTL(b, 30) >>> 0; - b = a; - a = T; - } - H[0] = H[0] + a >>> 0; - H[1] = H[1] + b >>> 0; - H[2] = H[2] + c >>> 0; - H[3] = H[3] + d >>> 0; - H[4] = H[4] + e >>> 0; - } - return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff]; -} -export default sha1; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/stringify.js b/static/node_modules/uuid/dist/esm-browser/stringify.js deleted file mode 100644 index 0a9cf40..0000000 --- a/static/node_modules/uuid/dist/esm-browser/stringify.js +++ /dev/null @@ -1,31 +0,0 @@ -import validate from './validate.js'; - -/** - * Convert array of 16 byte values to UUID string format of the form: - * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX - */ -var byteToHex = []; -for (var i = 0; i < 256; ++i) { - byteToHex.push((i + 0x100).toString(16).slice(1)); -} -export function unsafeStringify(arr, offset = 0) { - // Note: Be careful editing this code! It's been tuned for performance - // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 - // - // Note to future-self: No, you can't remove the `toLowerCase()` call. - // REF: https://github.com/uuidjs/uuid/pull/677#issuecomment-1757351351 - return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); -} -function stringify(arr, offset = 0) { - var uuid = unsafeStringify(arr, offset); - // Consistency check for valid UUID. If this throws, it's likely due to one - // of the following: - // - One or more input array values don't map to a hex octet (leading to - // "undefined" in the uuid) - // - Invalid input values for the RFC `version` or `variant` fields - if (!validate(uuid)) { - throw TypeError('Stringified UUID is invalid'); - } - return uuid; -} -export default stringify; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/v1.js b/static/node_modules/uuid/dist/esm-browser/v1.js deleted file mode 100644 index d42a904..0000000 --- a/static/node_modules/uuid/dist/esm-browser/v1.js +++ /dev/null @@ -1,125 +0,0 @@ -import rng from './rng.js'; -import { unsafeStringify } from './stringify.js'; - -// **`v1()` - Generate time-based UUID** -// -// Inspired by https://github.com/LiosK/UUID.js -// and http://docs.python.org/library/uuid.html - -var _nodeId; -var _clockseq; - -// Previous uuid creation time -var _lastMSecs = 0; -var _lastNSecs = 0; - -// See https://github.com/uuidjs/uuid for API details -function v1(options, buf, offset) { - var i = buf && offset || 0; - var b = buf || new Array(16); - options = options || {}; - var node = options.node; - var clockseq = options.clockseq; - - // v1 only: Use cached `node` and `clockseq` values - if (!options._v6) { - if (!node) { - node = _nodeId; - } - if (clockseq == null) { - clockseq = _clockseq; - } - } - - // Handle cases where we need entropy. We do this lazily to minimize issues - // related to insufficient system entropy. See #189 - if (node == null || clockseq == null) { - var seedBytes = options.random || (options.rng || rng)(); - - // Randomize node - if (node == null) { - node = [seedBytes[0], seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]]; - - // v1 only: cache node value for reuse - if (!_nodeId && !options._v6) { - // per RFC4122 4.5: Set MAC multicast bit (v1 only) - node[0] |= 0x01; // Set multicast bit - - _nodeId = node; - } - } - - // Randomize clockseq - if (clockseq == null) { - // Per 4.2.2, randomize (14 bit) clockseq - clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; - if (_clockseq === undefined && !options._v6) { - _clockseq = clockseq; - } - } - } - - // v1 & v6 timestamps are 100 nano-second units since the Gregorian epoch, - // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so time is - // handled internally as 'msecs' (integer milliseconds) and 'nsecs' - // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. - var msecs = options.msecs !== undefined ? options.msecs : Date.now(); - - // Per 4.2.1.2, use count of uuid's generated during the current clock - // cycle to simulate higher resolution clock - var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; - - // Time since last uuid creation (in msecs) - var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; - - // Per 4.2.1.2, Bump clockseq on clock regression - if (dt < 0 && options.clockseq === undefined) { - clockseq = clockseq + 1 & 0x3fff; - } - - // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new - // time interval - if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { - nsecs = 0; - } - - // Per 4.2.1.2 Throw error if too many uuids are requested - if (nsecs >= 10000) { - throw new Error("uuid.v1(): Can't create more than 10M uuids/sec"); - } - _lastMSecs = msecs; - _lastNSecs = nsecs; - _clockseq = clockseq; - - // Per 4.1.4 - Convert from unix epoch to Gregorian epoch - msecs += 12219292800000; - - // `time_low` - var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; - b[i++] = tl >>> 24 & 0xff; - b[i++] = tl >>> 16 & 0xff; - b[i++] = tl >>> 8 & 0xff; - b[i++] = tl & 0xff; - - // `time_mid` - var tmh = msecs / 0x100000000 * 10000 & 0xfffffff; - b[i++] = tmh >>> 8 & 0xff; - b[i++] = tmh & 0xff; - - // `time_high_and_version` - b[i++] = tmh >>> 24 & 0xf | 0x10; // include version - b[i++] = tmh >>> 16 & 0xff; - - // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) - b[i++] = clockseq >>> 8 | 0x80; - - // `clock_seq_low` - b[i++] = clockseq & 0xff; - - // `node` - for (var n = 0; n < 6; ++n) { - b[i + n] = node[n]; - } - return buf || unsafeStringify(b); -} -export default v1; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/v1ToV6.js b/static/node_modules/uuid/dist/esm-browser/v1ToV6.js deleted file mode 100644 index e4ecc29..0000000 --- a/static/node_modules/uuid/dist/esm-browser/v1ToV6.js +++ /dev/null @@ -1,20 +0,0 @@ -import parse from './parse.js'; -import { unsafeStringify } from './stringify.js'; - -/** - * Convert a v1 UUID to a v6 UUID - * - * @param {string|Uint8Array} uuid - The v1 UUID to convert to v6 - * @returns {string|Uint8Array} The v6 UUID as the same type as the `uuid` arg - * (string or Uint8Array) - */ -export default function v1ToV6(uuid) { - var v1Bytes = typeof uuid === 'string' ? parse(uuid) : uuid; - var v6Bytes = _v1ToV6(v1Bytes); - return typeof uuid === 'string' ? unsafeStringify(v6Bytes) : v6Bytes; -} - -// Do the field transformation needed for v1 -> v6 -function _v1ToV6(v1Bytes, randomize = false) { - return Uint8Array.of((v1Bytes[6] & 0x0f) << 4 | v1Bytes[7] >> 4 & 0x0f, (v1Bytes[7] & 0x0f) << 4 | (v1Bytes[4] & 0xf0) >> 4, (v1Bytes[4] & 0x0f) << 4 | (v1Bytes[5] & 0xf0) >> 4, (v1Bytes[5] & 0x0f) << 4 | (v1Bytes[0] & 0xf0) >> 4, (v1Bytes[0] & 0x0f) << 4 | (v1Bytes[1] & 0xf0) >> 4, (v1Bytes[1] & 0x0f) << 4 | (v1Bytes[2] & 0xf0) >> 4, 0x60 | v1Bytes[2] & 0x0f, v1Bytes[3], v1Bytes[8], v1Bytes[9], v1Bytes[10], v1Bytes[11], v1Bytes[12], v1Bytes[13], v1Bytes[14], v1Bytes[15]); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/v3.js b/static/node_modules/uuid/dist/esm-browser/v3.js deleted file mode 100644 index c9ab9a4..0000000 --- a/static/node_modules/uuid/dist/esm-browser/v3.js +++ /dev/null @@ -1,4 +0,0 @@ -import v35 from './v35.js'; -import md5 from './md5.js'; -var v3 = v35('v3', 0x30, md5); -export default v3; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/v35.js b/static/node_modules/uuid/dist/esm-browser/v35.js deleted file mode 100644 index e5fd93f..0000000 --- a/static/node_modules/uuid/dist/esm-browser/v35.js +++ /dev/null @@ -1,55 +0,0 @@ -import { unsafeStringify } from './stringify.js'; -import parse from './parse.js'; -function stringToBytes(str) { - str = unescape(encodeURIComponent(str)); // UTF8 escape - - var bytes = []; - for (var i = 0; i < str.length; ++i) { - bytes.push(str.charCodeAt(i)); - } - return bytes; -} -export var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; -export var URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; -export default function v35(name, version, hashfunc) { - function generateUUID(value, namespace, buf, offset) { - var _namespace; - if (typeof value === 'string') { - value = stringToBytes(value); - } - if (typeof namespace === 'string') { - namespace = parse(namespace); - } - if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) { - throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)'); - } - - // Compute hash of namespace and value, Per 4.3 - // Future: Use spread syntax when supported on all platforms, e.g. `bytes = - // hashfunc([...namespace, ... value])` - var bytes = new Uint8Array(16 + value.length); - bytes.set(namespace); - bytes.set(value, namespace.length); - bytes = hashfunc(bytes); - bytes[6] = bytes[6] & 0x0f | version; - bytes[8] = bytes[8] & 0x3f | 0x80; - if (buf) { - offset = offset || 0; - for (var i = 0; i < 16; ++i) { - buf[offset + i] = bytes[i]; - } - return buf; - } - return unsafeStringify(bytes); - } - - // Function#name is not settable on some platforms (#270) - try { - generateUUID.name = name; - } catch (err) {} - - // For CommonJS default export support - generateUUID.DNS = DNS; - generateUUID.URL = URL; - return generateUUID; -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/v4.js b/static/node_modules/uuid/dist/esm-browser/v4.js deleted file mode 100644 index f107002..0000000 --- a/static/node_modules/uuid/dist/esm-browser/v4.js +++ /dev/null @@ -1,25 +0,0 @@ -import native from './native.js'; -import rng from './rng.js'; -import { unsafeStringify } from './stringify.js'; -function v4(options, buf, offset) { - if (native.randomUUID && !buf && !options) { - return native.randomUUID(); - } - options = options || {}; - var rnds = options.random || (options.rng || rng)(); - - // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` - rnds[6] = rnds[6] & 0x0f | 0x40; - rnds[8] = rnds[8] & 0x3f | 0x80; - - // Copy bytes to buffer, if provided - if (buf) { - offset = offset || 0; - for (var i = 0; i < 16; ++i) { - buf[offset + i] = rnds[i]; - } - return buf; - } - return unsafeStringify(rnds); -} -export default v4; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/v5.js b/static/node_modules/uuid/dist/esm-browser/v5.js deleted file mode 100644 index c08d96b..0000000 --- a/static/node_modules/uuid/dist/esm-browser/v5.js +++ /dev/null @@ -1,4 +0,0 @@ -import v35 from './v35.js'; -import sha1 from './sha1.js'; -var v5 = v35('v5', 0x50, sha1); -export default v5; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/v6.js b/static/node_modules/uuid/dist/esm-browser/v6.js deleted file mode 100644 index 13f9e91..0000000 --- a/static/node_modules/uuid/dist/esm-browser/v6.js +++ /dev/null @@ -1,36 +0,0 @@ -function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; } -function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } -function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; } -function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } -function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } -import { unsafeStringify } from './stringify.js'; -import v1 from './v1.js'; -import v1ToV6 from './v1ToV6.js'; - -/** - * - * @param {object} options - * @param {Uint8Array=} buf - * @param {number=} offset - * @returns - */ -export default function v6(options = {}, buf, offset = 0) { - // v6 is v1 with different field layout, so we start with a v1 UUID, albeit - // with slightly different behavior around how the clock_seq and node fields - // are randomized, which is why we call v1 with _v6: true. - var bytes = v1(_objectSpread(_objectSpread({}, options), {}, { - _v6: true - }), new Uint8Array(16)); - - // Reorder the fields to v6 layout. - bytes = v1ToV6(bytes); - - // Return as a byte array if requested - if (buf) { - for (var i = 0; i < 16; i++) { - buf[offset + i] = bytes[i]; - } - return buf; - } - return unsafeStringify(bytes); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/v6ToV1.js b/static/node_modules/uuid/dist/esm-browser/v6ToV1.js deleted file mode 100644 index 3dd1058..0000000 --- a/static/node_modules/uuid/dist/esm-browser/v6ToV1.js +++ /dev/null @@ -1,20 +0,0 @@ -import parse from './parse.js'; -import { unsafeStringify } from './stringify.js'; - -/** - * Convert a v6 UUID to a v1 UUID - * - * @param {string|Uint8Array} uuid - The v6 UUID to convert to v6 - * @returns {string|Uint8Array} The v1 UUID as the same type as the `uuid` arg - * (string or Uint8Array) - */ -export default function v6ToV1(uuid) { - var v6Bytes = typeof uuid === 'string' ? parse(uuid) : uuid; - var v1Bytes = _v6ToV1(v6Bytes); - return typeof uuid === 'string' ? unsafeStringify(v1Bytes) : v1Bytes; -} - -// Do the field transformation needed for v6 -> v1 -function _v6ToV1(v6Bytes) { - return Uint8Array.of((v6Bytes[3] & 0x0f) << 4 | v6Bytes[4] >> 4 & 0x0f, (v6Bytes[4] & 0x0f) << 4 | (v6Bytes[5] & 0xf0) >> 4, (v6Bytes[5] & 0x0f) << 4 | v6Bytes[6] & 0x0f, v6Bytes[7], (v6Bytes[1] & 0x0f) << 4 | (v6Bytes[2] & 0xf0) >> 4, (v6Bytes[2] & 0x0f) << 4 | (v6Bytes[3] & 0xf0) >> 4, 0x10 | (v6Bytes[0] & 0xf0) >> 4, (v6Bytes[0] & 0x0f) << 4 | (v6Bytes[1] & 0xf0) >> 4, v6Bytes[8], v6Bytes[9], v6Bytes[10], v6Bytes[11], v6Bytes[12], v6Bytes[13], v6Bytes[14], v6Bytes[15]); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/v7.js b/static/node_modules/uuid/dist/esm-browser/v7.js deleted file mode 100644 index 324153b..0000000 --- a/static/node_modules/uuid/dist/esm-browser/v7.js +++ /dev/null @@ -1,146 +0,0 @@ -import rng from './rng.js'; -import { unsafeStringify } from './stringify.js'; - -/** - * UUID V7 - Unix Epoch time-based UUID - * - * The IETF has published RFC9562, introducing 3 new UUID versions (6,7,8). This - * implementation of V7 is based on the accepted, though not yet approved, - * revisions. - * - * RFC 9562:https://www.rfc-editor.org/rfc/rfc9562.html Universally Unique - * IDentifiers (UUIDs) - - * - * Sample V7 value: - * https://www.rfc-editor.org/rfc/rfc9562.html#name-example-of-a-uuidv7-value - * - * Monotonic Bit Layout: RFC rfc9562.6.2 Method 1, Dedicated Counter Bits ref: - * https://www.rfc-editor.org/rfc/rfc9562.html#section-6.2-5.1 - * - * 0 1 2 3 0 1 2 3 4 5 6 - * 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * | unix_ts_ms | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * | unix_ts_ms | ver | seq_hi | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * |var| seq_low | rand | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * | rand | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * - * seq is a 31 bit serialized counter; comprised of 12 bit seq_hi and 19 bit - * seq_low, and randomly initialized upon timestamp change. 31 bit counter size - * was selected as any bitwise operations in node are done as _signed_ 32 bit - * ints. we exclude the sign bit. - */ - -var _seqLow = null; -var _seqHigh = null; -var _msecs = 0; -function v7(options, buf, offset) { - options = options || {}; - - // initialize buffer and pointer - var i = buf && offset || 0; - var b = buf || new Uint8Array(16); - - // rnds is Uint8Array(16) filled with random bytes - var rnds = options.random || (options.rng || rng)(); - - // milliseconds since unix epoch, 1970-01-01 00:00 - var msecs = options.msecs !== undefined ? options.msecs : Date.now(); - - // seq is user provided 31 bit counter - var seq = options.seq !== undefined ? options.seq : null; - - // initialize local seq high/low parts - var seqHigh = _seqHigh; - var seqLow = _seqLow; - - // check if clock has advanced and user has not provided msecs - if (msecs > _msecs && options.msecs === undefined) { - _msecs = msecs; - - // unless user provided seq, reset seq parts - if (seq !== null) { - seqHigh = null; - seqLow = null; - } - } - - // if we have a user provided seq - if (seq !== null) { - // trim provided seq to 31 bits of value, avoiding overflow - if (seq > 0x7fffffff) { - seq = 0x7fffffff; - } - - // split provided seq into high/low parts - seqHigh = seq >>> 19 & 0xfff; - seqLow = seq & 0x7ffff; - } - - // randomly initialize seq - if (seqHigh === null || seqLow === null) { - seqHigh = rnds[6] & 0x7f; - seqHigh = seqHigh << 8 | rnds[7]; - seqLow = rnds[8] & 0x3f; // pad for var - seqLow = seqLow << 8 | rnds[9]; - seqLow = seqLow << 5 | rnds[10] >>> 3; - } - - // increment seq if within msecs window - if (msecs + 10000 > _msecs && seq === null) { - if (++seqLow > 0x7ffff) { - seqLow = 0; - if (++seqHigh > 0xfff) { - seqHigh = 0; - - // increment internal _msecs. this allows us to continue incrementing - // while staying monotonic. Note, once we hit 10k milliseconds beyond system - // clock, we will reset breaking monotonicity (after (2^31)*10000 generations) - _msecs++; - } - } - } else { - // resetting; we have advanced more than - // 10k milliseconds beyond system clock - _msecs = msecs; - } - _seqHigh = seqHigh; - _seqLow = seqLow; - - // [bytes 0-5] 48 bits of local timestamp - b[i++] = _msecs / 0x10000000000 & 0xff; - b[i++] = _msecs / 0x100000000 & 0xff; - b[i++] = _msecs / 0x1000000 & 0xff; - b[i++] = _msecs / 0x10000 & 0xff; - b[i++] = _msecs / 0x100 & 0xff; - b[i++] = _msecs & 0xff; - - // [byte 6] - set 4 bits of version (7) with first 4 bits seq_hi - b[i++] = seqHigh >>> 4 & 0x0f | 0x70; - - // [byte 7] remaining 8 bits of seq_hi - b[i++] = seqHigh & 0xff; - - // [byte 8] - variant (2 bits), first 6 bits seq_low - b[i++] = seqLow >>> 13 & 0x3f | 0x80; - - // [byte 9] 8 bits seq_low - b[i++] = seqLow >>> 5 & 0xff; - - // [byte 10] remaining 5 bits seq_low, 3 bits random - b[i++] = seqLow << 3 & 0xff | rnds[10] & 0x07; - - // [bytes 11-15] always random - b[i++] = rnds[11]; - b[i++] = rnds[12]; - b[i++] = rnds[13]; - b[i++] = rnds[14]; - b[i++] = rnds[15]; - return buf || unsafeStringify(b); -} -export default v7; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/validate.js b/static/node_modules/uuid/dist/esm-browser/validate.js deleted file mode 100644 index 6e40fa5..0000000 --- a/static/node_modules/uuid/dist/esm-browser/validate.js +++ /dev/null @@ -1,5 +0,0 @@ -import REGEX from './regex.js'; -function validate(uuid) { - return typeof uuid === 'string' && REGEX.test(uuid); -} -export default validate; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-browser/version.js b/static/node_modules/uuid/dist/esm-browser/version.js deleted file mode 100644 index 4ca924e..0000000 --- a/static/node_modules/uuid/dist/esm-browser/version.js +++ /dev/null @@ -1,8 +0,0 @@ -import validate from './validate.js'; -function version(uuid) { - if (!validate(uuid)) { - throw TypeError('Invalid UUID'); - } - return parseInt(uuid.slice(14, 15), 16); -} -export default version; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/index.js b/static/node_modules/uuid/dist/esm-node/index.js deleted file mode 100644 index 45214b3..0000000 --- a/static/node_modules/uuid/dist/esm-node/index.js +++ /dev/null @@ -1,14 +0,0 @@ -export { default as MAX } from './max.js'; -export { default as NIL } from './nil.js'; -export { default as parse } from './parse.js'; -export { default as stringify } from './stringify.js'; -export { default as v1 } from './v1.js'; -export { default as v1ToV6 } from './v1ToV6.js'; -export { default as v3 } from './v3.js'; -export { default as v4 } from './v4.js'; -export { default as v5 } from './v5.js'; -export { default as v6 } from './v6.js'; -export { default as v6ToV1 } from './v6ToV1.js'; -export { default as v7 } from './v7.js'; -export { default as validate } from './validate.js'; -export { default as version } from './version.js'; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/max.js b/static/node_modules/uuid/dist/esm-node/max.js deleted file mode 100644 index f46a281..0000000 --- a/static/node_modules/uuid/dist/esm-node/max.js +++ /dev/null @@ -1 +0,0 @@ -export default 'ffffffff-ffff-ffff-ffff-ffffffffffff'; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/md5.js b/static/node_modules/uuid/dist/esm-node/md5.js deleted file mode 100644 index b3d890e..0000000 --- a/static/node_modules/uuid/dist/esm-node/md5.js +++ /dev/null @@ -1,10 +0,0 @@ -import crypto from 'node:crypto'; -function md5(bytes) { - if (Array.isArray(bytes)) { - bytes = Buffer.from(bytes); - } else if (typeof bytes === 'string') { - bytes = Buffer.from(bytes, 'utf8'); - } - return crypto.createHash('md5').update(bytes).digest(); -} -export default md5; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/native.js b/static/node_modules/uuid/dist/esm-node/native.js deleted file mode 100644 index d688de1..0000000 --- a/static/node_modules/uuid/dist/esm-node/native.js +++ /dev/null @@ -1,4 +0,0 @@ -import crypto from 'node:crypto'; -export default { - randomUUID: crypto.randomUUID -}; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/nil.js b/static/node_modules/uuid/dist/esm-node/nil.js deleted file mode 100644 index b36324c..0000000 --- a/static/node_modules/uuid/dist/esm-node/nil.js +++ /dev/null @@ -1 +0,0 @@ -export default '00000000-0000-0000-0000-000000000000'; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/parse.js b/static/node_modules/uuid/dist/esm-node/parse.js deleted file mode 100644 index 80851ff..0000000 --- a/static/node_modules/uuid/dist/esm-node/parse.js +++ /dev/null @@ -1,37 +0,0 @@ -import validate from './validate.js'; -function parse(uuid) { - if (!validate(uuid)) { - throw TypeError('Invalid UUID'); - } - let v; - const arr = new Uint8Array(16); - - // Parse ########-....-....-....-............ - arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24; - arr[1] = v >>> 16 & 0xff; - arr[2] = v >>> 8 & 0xff; - arr[3] = v & 0xff; - - // Parse ........-####-....-....-............ - arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8; - arr[5] = v & 0xff; - - // Parse ........-....-####-....-............ - arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8; - arr[7] = v & 0xff; - - // Parse ........-....-....-####-............ - arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8; - arr[9] = v & 0xff; - - // Parse ........-....-....-....-############ - // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes) - arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff; - arr[11] = v / 0x100000000 & 0xff; - arr[12] = v >>> 24 & 0xff; - arr[13] = v >>> 16 & 0xff; - arr[14] = v >>> 8 & 0xff; - arr[15] = v & 0xff; - return arr; -} -export default parse; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/regex.js b/static/node_modules/uuid/dist/esm-node/regex.js deleted file mode 100644 index 848a1fe..0000000 --- a/static/node_modules/uuid/dist/esm-node/regex.js +++ /dev/null @@ -1 +0,0 @@ -export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/rng.js b/static/node_modules/uuid/dist/esm-node/rng.js deleted file mode 100644 index 69ee524..0000000 --- a/static/node_modules/uuid/dist/esm-node/rng.js +++ /dev/null @@ -1,10 +0,0 @@ -import crypto from 'node:crypto'; -const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate -let poolPtr = rnds8Pool.length; -export default function rng() { - if (poolPtr > rnds8Pool.length - 16) { - crypto.randomFillSync(rnds8Pool); - poolPtr = 0; - } - return rnds8Pool.slice(poolPtr, poolPtr += 16); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/sha1.js b/static/node_modules/uuid/dist/esm-node/sha1.js deleted file mode 100644 index 2221787..0000000 --- a/static/node_modules/uuid/dist/esm-node/sha1.js +++ /dev/null @@ -1,10 +0,0 @@ -import crypto from 'node:crypto'; -function sha1(bytes) { - if (Array.isArray(bytes)) { - bytes = Buffer.from(bytes); - } else if (typeof bytes === 'string') { - bytes = Buffer.from(bytes, 'utf8'); - } - return crypto.createHash('sha1').update(bytes).digest(); -} -export default sha1; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/stringify.js b/static/node_modules/uuid/dist/esm-node/stringify.js deleted file mode 100644 index 7792d4e..0000000 --- a/static/node_modules/uuid/dist/esm-node/stringify.js +++ /dev/null @@ -1,31 +0,0 @@ -import validate from './validate.js'; - -/** - * Convert array of 16 byte values to UUID string format of the form: - * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX - */ -const byteToHex = []; -for (let i = 0; i < 256; ++i) { - byteToHex.push((i + 0x100).toString(16).slice(1)); -} -export function unsafeStringify(arr, offset = 0) { - // Note: Be careful editing this code! It's been tuned for performance - // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 - // - // Note to future-self: No, you can't remove the `toLowerCase()` call. - // REF: https://github.com/uuidjs/uuid/pull/677#issuecomment-1757351351 - return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); -} -function stringify(arr, offset = 0) { - const uuid = unsafeStringify(arr, offset); - // Consistency check for valid UUID. If this throws, it's likely due to one - // of the following: - // - One or more input array values don't map to a hex octet (leading to - // "undefined" in the uuid) - // - Invalid input values for the RFC `version` or `variant` fields - if (!validate(uuid)) { - throw TypeError('Stringified UUID is invalid'); - } - return uuid; -} -export default stringify; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/v1.js b/static/node_modules/uuid/dist/esm-node/v1.js deleted file mode 100644 index 6bf0b1c..0000000 --- a/static/node_modules/uuid/dist/esm-node/v1.js +++ /dev/null @@ -1,125 +0,0 @@ -import rng from './rng.js'; -import { unsafeStringify } from './stringify.js'; - -// **`v1()` - Generate time-based UUID** -// -// Inspired by https://github.com/LiosK/UUID.js -// and http://docs.python.org/library/uuid.html - -let _nodeId; -let _clockseq; - -// Previous uuid creation time -let _lastMSecs = 0; -let _lastNSecs = 0; - -// See https://github.com/uuidjs/uuid for API details -function v1(options, buf, offset) { - let i = buf && offset || 0; - const b = buf || new Array(16); - options = options || {}; - let node = options.node; - let clockseq = options.clockseq; - - // v1 only: Use cached `node` and `clockseq` values - if (!options._v6) { - if (!node) { - node = _nodeId; - } - if (clockseq == null) { - clockseq = _clockseq; - } - } - - // Handle cases where we need entropy. We do this lazily to minimize issues - // related to insufficient system entropy. See #189 - if (node == null || clockseq == null) { - const seedBytes = options.random || (options.rng || rng)(); - - // Randomize node - if (node == null) { - node = [seedBytes[0], seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]]; - - // v1 only: cache node value for reuse - if (!_nodeId && !options._v6) { - // per RFC4122 4.5: Set MAC multicast bit (v1 only) - node[0] |= 0x01; // Set multicast bit - - _nodeId = node; - } - } - - // Randomize clockseq - if (clockseq == null) { - // Per 4.2.2, randomize (14 bit) clockseq - clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; - if (_clockseq === undefined && !options._v6) { - _clockseq = clockseq; - } - } - } - - // v1 & v6 timestamps are 100 nano-second units since the Gregorian epoch, - // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so time is - // handled internally as 'msecs' (integer milliseconds) and 'nsecs' - // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. - let msecs = options.msecs !== undefined ? options.msecs : Date.now(); - - // Per 4.2.1.2, use count of uuid's generated during the current clock - // cycle to simulate higher resolution clock - let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; - - // Time since last uuid creation (in msecs) - const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; - - // Per 4.2.1.2, Bump clockseq on clock regression - if (dt < 0 && options.clockseq === undefined) { - clockseq = clockseq + 1 & 0x3fff; - } - - // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new - // time interval - if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { - nsecs = 0; - } - - // Per 4.2.1.2 Throw error if too many uuids are requested - if (nsecs >= 10000) { - throw new Error("uuid.v1(): Can't create more than 10M uuids/sec"); - } - _lastMSecs = msecs; - _lastNSecs = nsecs; - _clockseq = clockseq; - - // Per 4.1.4 - Convert from unix epoch to Gregorian epoch - msecs += 12219292800000; - - // `time_low` - const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; - b[i++] = tl >>> 24 & 0xff; - b[i++] = tl >>> 16 & 0xff; - b[i++] = tl >>> 8 & 0xff; - b[i++] = tl & 0xff; - - // `time_mid` - const tmh = msecs / 0x100000000 * 10000 & 0xfffffff; - b[i++] = tmh >>> 8 & 0xff; - b[i++] = tmh & 0xff; - - // `time_high_and_version` - b[i++] = tmh >>> 24 & 0xf | 0x10; // include version - b[i++] = tmh >>> 16 & 0xff; - - // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) - b[i++] = clockseq >>> 8 | 0x80; - - // `clock_seq_low` - b[i++] = clockseq & 0xff; - - // `node` - for (let n = 0; n < 6; ++n) { - b[i + n] = node[n]; - } - return buf || unsafeStringify(b); -} -export default v1; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/v1ToV6.js b/static/node_modules/uuid/dist/esm-node/v1ToV6.js deleted file mode 100644 index 15aea2f..0000000 --- a/static/node_modules/uuid/dist/esm-node/v1ToV6.js +++ /dev/null @@ -1,20 +0,0 @@ -import parse from './parse.js'; -import { unsafeStringify } from './stringify.js'; - -/** - * Convert a v1 UUID to a v6 UUID - * - * @param {string|Uint8Array} uuid - The v1 UUID to convert to v6 - * @returns {string|Uint8Array} The v6 UUID as the same type as the `uuid` arg - * (string or Uint8Array) - */ -export default function v1ToV6(uuid) { - const v1Bytes = typeof uuid === 'string' ? parse(uuid) : uuid; - const v6Bytes = _v1ToV6(v1Bytes); - return typeof uuid === 'string' ? unsafeStringify(v6Bytes) : v6Bytes; -} - -// Do the field transformation needed for v1 -> v6 -function _v1ToV6(v1Bytes, randomize = false) { - return Uint8Array.of((v1Bytes[6] & 0x0f) << 4 | v1Bytes[7] >> 4 & 0x0f, (v1Bytes[7] & 0x0f) << 4 | (v1Bytes[4] & 0xf0) >> 4, (v1Bytes[4] & 0x0f) << 4 | (v1Bytes[5] & 0xf0) >> 4, (v1Bytes[5] & 0x0f) << 4 | (v1Bytes[0] & 0xf0) >> 4, (v1Bytes[0] & 0x0f) << 4 | (v1Bytes[1] & 0xf0) >> 4, (v1Bytes[1] & 0x0f) << 4 | (v1Bytes[2] & 0xf0) >> 4, 0x60 | v1Bytes[2] & 0x0f, v1Bytes[3], v1Bytes[8], v1Bytes[9], v1Bytes[10], v1Bytes[11], v1Bytes[12], v1Bytes[13], v1Bytes[14], v1Bytes[15]); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/v3.js b/static/node_modules/uuid/dist/esm-node/v3.js deleted file mode 100644 index 09063b8..0000000 --- a/static/node_modules/uuid/dist/esm-node/v3.js +++ /dev/null @@ -1,4 +0,0 @@ -import v35 from './v35.js'; -import md5 from './md5.js'; -const v3 = v35('v3', 0x30, md5); -export default v3; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/v35.js b/static/node_modules/uuid/dist/esm-node/v35.js deleted file mode 100644 index 013c869..0000000 --- a/static/node_modules/uuid/dist/esm-node/v35.js +++ /dev/null @@ -1,55 +0,0 @@ -import { unsafeStringify } from './stringify.js'; -import parse from './parse.js'; -function stringToBytes(str) { - str = unescape(encodeURIComponent(str)); // UTF8 escape - - const bytes = []; - for (let i = 0; i < str.length; ++i) { - bytes.push(str.charCodeAt(i)); - } - return bytes; -} -export const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; -export const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; -export default function v35(name, version, hashfunc) { - function generateUUID(value, namespace, buf, offset) { - var _namespace; - if (typeof value === 'string') { - value = stringToBytes(value); - } - if (typeof namespace === 'string') { - namespace = parse(namespace); - } - if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) { - throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)'); - } - - // Compute hash of namespace and value, Per 4.3 - // Future: Use spread syntax when supported on all platforms, e.g. `bytes = - // hashfunc([...namespace, ... value])` - let bytes = new Uint8Array(16 + value.length); - bytes.set(namespace); - bytes.set(value, namespace.length); - bytes = hashfunc(bytes); - bytes[6] = bytes[6] & 0x0f | version; - bytes[8] = bytes[8] & 0x3f | 0x80; - if (buf) { - offset = offset || 0; - for (let i = 0; i < 16; ++i) { - buf[offset + i] = bytes[i]; - } - return buf; - } - return unsafeStringify(bytes); - } - - // Function#name is not settable on some platforms (#270) - try { - generateUUID.name = name; - } catch (err) {} - - // For CommonJS default export support - generateUUID.DNS = DNS; - generateUUID.URL = URL; - return generateUUID; -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/v4.js b/static/node_modules/uuid/dist/esm-node/v4.js deleted file mode 100644 index ed1db71..0000000 --- a/static/node_modules/uuid/dist/esm-node/v4.js +++ /dev/null @@ -1,25 +0,0 @@ -import native from './native.js'; -import rng from './rng.js'; -import { unsafeStringify } from './stringify.js'; -function v4(options, buf, offset) { - if (native.randomUUID && !buf && !options) { - return native.randomUUID(); - } - options = options || {}; - const rnds = options.random || (options.rng || rng)(); - - // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` - rnds[6] = rnds[6] & 0x0f | 0x40; - rnds[8] = rnds[8] & 0x3f | 0x80; - - // Copy bytes to buffer, if provided - if (buf) { - offset = offset || 0; - for (let i = 0; i < 16; ++i) { - buf[offset + i] = rnds[i]; - } - return buf; - } - return unsafeStringify(rnds); -} -export default v4; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/v5.js b/static/node_modules/uuid/dist/esm-node/v5.js deleted file mode 100644 index e87fe31..0000000 --- a/static/node_modules/uuid/dist/esm-node/v5.js +++ /dev/null @@ -1,4 +0,0 @@ -import v35 from './v35.js'; -import sha1 from './sha1.js'; -const v5 = v35('v5', 0x50, sha1); -export default v5; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/v6.js b/static/node_modules/uuid/dist/esm-node/v6.js deleted file mode 100644 index 673d025..0000000 --- a/static/node_modules/uuid/dist/esm-node/v6.js +++ /dev/null @@ -1,32 +0,0 @@ -import { unsafeStringify } from './stringify.js'; -import v1 from './v1.js'; -import v1ToV6 from './v1ToV6.js'; - -/** - * - * @param {object} options - * @param {Uint8Array=} buf - * @param {number=} offset - * @returns - */ -export default function v6(options = {}, buf, offset = 0) { - // v6 is v1 with different field layout, so we start with a v1 UUID, albeit - // with slightly different behavior around how the clock_seq and node fields - // are randomized, which is why we call v1 with _v6: true. - let bytes = v1({ - ...options, - _v6: true - }, new Uint8Array(16)); - - // Reorder the fields to v6 layout. - bytes = v1ToV6(bytes); - - // Return as a byte array if requested - if (buf) { - for (let i = 0; i < 16; i++) { - buf[offset + i] = bytes[i]; - } - return buf; - } - return unsafeStringify(bytes); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/v6ToV1.js b/static/node_modules/uuid/dist/esm-node/v6ToV1.js deleted file mode 100644 index e2fdfff..0000000 --- a/static/node_modules/uuid/dist/esm-node/v6ToV1.js +++ /dev/null @@ -1,20 +0,0 @@ -import parse from './parse.js'; -import { unsafeStringify } from './stringify.js'; - -/** - * Convert a v6 UUID to a v1 UUID - * - * @param {string|Uint8Array} uuid - The v6 UUID to convert to v6 - * @returns {string|Uint8Array} The v1 UUID as the same type as the `uuid` arg - * (string or Uint8Array) - */ -export default function v6ToV1(uuid) { - const v6Bytes = typeof uuid === 'string' ? parse(uuid) : uuid; - const v1Bytes = _v6ToV1(v6Bytes); - return typeof uuid === 'string' ? unsafeStringify(v1Bytes) : v1Bytes; -} - -// Do the field transformation needed for v6 -> v1 -function _v6ToV1(v6Bytes) { - return Uint8Array.of((v6Bytes[3] & 0x0f) << 4 | v6Bytes[4] >> 4 & 0x0f, (v6Bytes[4] & 0x0f) << 4 | (v6Bytes[5] & 0xf0) >> 4, (v6Bytes[5] & 0x0f) << 4 | v6Bytes[6] & 0x0f, v6Bytes[7], (v6Bytes[1] & 0x0f) << 4 | (v6Bytes[2] & 0xf0) >> 4, (v6Bytes[2] & 0x0f) << 4 | (v6Bytes[3] & 0xf0) >> 4, 0x10 | (v6Bytes[0] & 0xf0) >> 4, (v6Bytes[0] & 0x0f) << 4 | (v6Bytes[1] & 0xf0) >> 4, v6Bytes[8], v6Bytes[9], v6Bytes[10], v6Bytes[11], v6Bytes[12], v6Bytes[13], v6Bytes[14], v6Bytes[15]); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/v7.js b/static/node_modules/uuid/dist/esm-node/v7.js deleted file mode 100644 index 18159e1..0000000 --- a/static/node_modules/uuid/dist/esm-node/v7.js +++ /dev/null @@ -1,146 +0,0 @@ -import rng from './rng.js'; -import { unsafeStringify } from './stringify.js'; - -/** - * UUID V7 - Unix Epoch time-based UUID - * - * The IETF has published RFC9562, introducing 3 new UUID versions (6,7,8). This - * implementation of V7 is based on the accepted, though not yet approved, - * revisions. - * - * RFC 9562:https://www.rfc-editor.org/rfc/rfc9562.html Universally Unique - * IDentifiers (UUIDs) - - * - * Sample V7 value: - * https://www.rfc-editor.org/rfc/rfc9562.html#name-example-of-a-uuidv7-value - * - * Monotonic Bit Layout: RFC rfc9562.6.2 Method 1, Dedicated Counter Bits ref: - * https://www.rfc-editor.org/rfc/rfc9562.html#section-6.2-5.1 - * - * 0 1 2 3 0 1 2 3 4 5 6 - * 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * | unix_ts_ms | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * | unix_ts_ms | ver | seq_hi | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * |var| seq_low | rand | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * | rand | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * - * seq is a 31 bit serialized counter; comprised of 12 bit seq_hi and 19 bit - * seq_low, and randomly initialized upon timestamp change. 31 bit counter size - * was selected as any bitwise operations in node are done as _signed_ 32 bit - * ints. we exclude the sign bit. - */ - -let _seqLow = null; -let _seqHigh = null; -let _msecs = 0; -function v7(options, buf, offset) { - options = options || {}; - - // initialize buffer and pointer - let i = buf && offset || 0; - const b = buf || new Uint8Array(16); - - // rnds is Uint8Array(16) filled with random bytes - const rnds = options.random || (options.rng || rng)(); - - // milliseconds since unix epoch, 1970-01-01 00:00 - const msecs = options.msecs !== undefined ? options.msecs : Date.now(); - - // seq is user provided 31 bit counter - let seq = options.seq !== undefined ? options.seq : null; - - // initialize local seq high/low parts - let seqHigh = _seqHigh; - let seqLow = _seqLow; - - // check if clock has advanced and user has not provided msecs - if (msecs > _msecs && options.msecs === undefined) { - _msecs = msecs; - - // unless user provided seq, reset seq parts - if (seq !== null) { - seqHigh = null; - seqLow = null; - } - } - - // if we have a user provided seq - if (seq !== null) { - // trim provided seq to 31 bits of value, avoiding overflow - if (seq > 0x7fffffff) { - seq = 0x7fffffff; - } - - // split provided seq into high/low parts - seqHigh = seq >>> 19 & 0xfff; - seqLow = seq & 0x7ffff; - } - - // randomly initialize seq - if (seqHigh === null || seqLow === null) { - seqHigh = rnds[6] & 0x7f; - seqHigh = seqHigh << 8 | rnds[7]; - seqLow = rnds[8] & 0x3f; // pad for var - seqLow = seqLow << 8 | rnds[9]; - seqLow = seqLow << 5 | rnds[10] >>> 3; - } - - // increment seq if within msecs window - if (msecs + 10000 > _msecs && seq === null) { - if (++seqLow > 0x7ffff) { - seqLow = 0; - if (++seqHigh > 0xfff) { - seqHigh = 0; - - // increment internal _msecs. this allows us to continue incrementing - // while staying monotonic. Note, once we hit 10k milliseconds beyond system - // clock, we will reset breaking monotonicity (after (2^31)*10000 generations) - _msecs++; - } - } - } else { - // resetting; we have advanced more than - // 10k milliseconds beyond system clock - _msecs = msecs; - } - _seqHigh = seqHigh; - _seqLow = seqLow; - - // [bytes 0-5] 48 bits of local timestamp - b[i++] = _msecs / 0x10000000000 & 0xff; - b[i++] = _msecs / 0x100000000 & 0xff; - b[i++] = _msecs / 0x1000000 & 0xff; - b[i++] = _msecs / 0x10000 & 0xff; - b[i++] = _msecs / 0x100 & 0xff; - b[i++] = _msecs & 0xff; - - // [byte 6] - set 4 bits of version (7) with first 4 bits seq_hi - b[i++] = seqHigh >>> 4 & 0x0f | 0x70; - - // [byte 7] remaining 8 bits of seq_hi - b[i++] = seqHigh & 0xff; - - // [byte 8] - variant (2 bits), first 6 bits seq_low - b[i++] = seqLow >>> 13 & 0x3f | 0x80; - - // [byte 9] 8 bits seq_low - b[i++] = seqLow >>> 5 & 0xff; - - // [byte 10] remaining 5 bits seq_low, 3 bits random - b[i++] = seqLow << 3 & 0xff | rnds[10] & 0x07; - - // [bytes 11-15] always random - b[i++] = rnds[11]; - b[i++] = rnds[12]; - b[i++] = rnds[13]; - b[i++] = rnds[14]; - b[i++] = rnds[15]; - return buf || unsafeStringify(b); -} -export default v7; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/validate.js b/static/node_modules/uuid/dist/esm-node/validate.js deleted file mode 100644 index 6e40fa5..0000000 --- a/static/node_modules/uuid/dist/esm-node/validate.js +++ /dev/null @@ -1,5 +0,0 @@ -import REGEX from './regex.js'; -function validate(uuid) { - return typeof uuid === 'string' && REGEX.test(uuid); -} -export default validate; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/esm-node/version.js b/static/node_modules/uuid/dist/esm-node/version.js deleted file mode 100644 index 4ca924e..0000000 --- a/static/node_modules/uuid/dist/esm-node/version.js +++ /dev/null @@ -1,8 +0,0 @@ -import validate from './validate.js'; -function version(uuid) { - if (!validate(uuid)) { - throw TypeError('Invalid UUID'); - } - return parseInt(uuid.slice(14, 15), 16); -} -export default version; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/index.js b/static/node_modules/uuid/dist/index.js index cd6eb74..3193e9a 100644 --- a/static/node_modules/uuid/dist/index.js +++ b/static/node_modules/uuid/dist/index.js @@ -1,104 +1,14 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -Object.defineProperty(exports, "MAX", { - enumerable: true, - get: function () { - return _max.default; - } -}); -Object.defineProperty(exports, "NIL", { - enumerable: true, - get: function () { - return _nil.default; - } -}); -Object.defineProperty(exports, "parse", { - enumerable: true, - get: function () { - return _parse.default; - } -}); -Object.defineProperty(exports, "stringify", { - enumerable: true, - get: function () { - return _stringify.default; - } -}); -Object.defineProperty(exports, "v1", { - enumerable: true, - get: function () { - return _v.default; - } -}); -Object.defineProperty(exports, "v1ToV6", { - enumerable: true, - get: function () { - return _v1ToV.default; - } -}); -Object.defineProperty(exports, "v3", { - enumerable: true, - get: function () { - return _v2.default; - } -}); -Object.defineProperty(exports, "v4", { - enumerable: true, - get: function () { - return _v3.default; - } -}); -Object.defineProperty(exports, "v5", { - enumerable: true, - get: function () { - return _v4.default; - } -}); -Object.defineProperty(exports, "v6", { - enumerable: true, - get: function () { - return _v5.default; - } -}); -Object.defineProperty(exports, "v6ToV1", { - enumerable: true, - get: function () { - return _v6ToV.default; - } -}); -Object.defineProperty(exports, "v7", { - enumerable: true, - get: function () { - return _v6.default; - } -}); -Object.defineProperty(exports, "validate", { - enumerable: true, - get: function () { - return _validate.default; - } -}); -Object.defineProperty(exports, "version", { - enumerable: true, - get: function () { - return _version.default; - } -}); -var _max = _interopRequireDefault(require("./max.js")); -var _nil = _interopRequireDefault(require("./nil.js")); -var _parse = _interopRequireDefault(require("./parse.js")); -var _stringify = _interopRequireDefault(require("./stringify.js")); -var _v = _interopRequireDefault(require("./v1.js")); -var _v1ToV = _interopRequireDefault(require("./v1ToV6.js")); -var _v2 = _interopRequireDefault(require("./v3.js")); -var _v3 = _interopRequireDefault(require("./v4.js")); -var _v4 = _interopRequireDefault(require("./v5.js")); -var _v5 = _interopRequireDefault(require("./v6.js")); -var _v6ToV = _interopRequireDefault(require("./v6ToV1.js")); -var _v6 = _interopRequireDefault(require("./v7.js")); -var _validate = _interopRequireDefault(require("./validate.js")); -var _version = _interopRequireDefault(require("./version.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } \ No newline at end of file +export { default as MAX } from './max.js'; +export { default as NIL } from './nil.js'; +export { default as parse } from './parse.js'; +export { default as stringify } from './stringify.js'; +export { default as v1 } from './v1.js'; +export { default as v1ToV6 } from './v1ToV6.js'; +export { default as v3 } from './v3.js'; +export { default as v4 } from './v4.js'; +export { default as v5 } from './v5.js'; +export { default as v6 } from './v6.js'; +export { default as v6ToV1 } from './v6ToV1.js'; +export { default as v7 } from './v7.js'; +export { default as validate } from './validate.js'; +export { default as version } from './version.js'; diff --git a/static/node_modules/uuid/dist/max.js b/static/node_modules/uuid/dist/max.js index 8de76f8..58951f6 100644 --- a/static/node_modules/uuid/dist/max.js +++ b/static/node_modules/uuid/dist/max.js @@ -1,7 +1 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _default = exports.default = 'ffffffff-ffff-ffff-ffff-ffffffffffff'; \ No newline at end of file +export default 'ffffffff-ffff-ffff-ffff-ffffffffffff'; diff --git a/static/node_modules/uuid/dist/md5-browser.js b/static/node_modules/uuid/dist/md5-browser.js deleted file mode 100644 index f0d31f5..0000000 --- a/static/node_modules/uuid/dist/md5-browser.js +++ /dev/null @@ -1,200 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -/* - * Browser-compatible JavaScript MD5 - * - * Modification of JavaScript MD5 - * https://github.com/blueimp/JavaScript-MD5 - * - * Copyright 2011, Sebastian Tschan - * https://blueimp.net - * - * Licensed under the MIT license: - * https://opensource.org/licenses/MIT - * - * Based on - * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message - * Digest Algorithm, as defined in RFC 1321. - * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009 - * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet - * Distributed under the BSD License - * See http://pajhome.org.uk/crypt/md5 for more info. - */ -function md5(bytes) { - if (typeof bytes === 'string') { - const msg = unescape(encodeURIComponent(bytes)); // UTF8 escape - - bytes = new Uint8Array(msg.length); - for (let i = 0; i < msg.length; ++i) { - bytes[i] = msg.charCodeAt(i); - } - } - return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8)); -} - -/* - * Convert an array of little-endian words to an array of bytes - */ -function md5ToHexEncodedArray(input) { - const output = []; - const length32 = input.length * 32; - const hexTab = '0123456789abcdef'; - for (let i = 0; i < length32; i += 8) { - const x = input[i >> 5] >>> i % 32 & 0xff; - const hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16); - output.push(hex); - } - return output; -} - -/** - * Calculate output length with padding and bit length - */ -function getOutputLength(inputLength8) { - return (inputLength8 + 64 >>> 9 << 4) + 14 + 1; -} - -/* - * Calculate the MD5 of an array of little-endian words, and a bit length. - */ -function wordsToMd5(x, len) { - /* append padding */ - x[len >> 5] |= 0x80 << len % 32; - x[getOutputLength(len) - 1] = len; - let a = 1732584193; - let b = -271733879; - let c = -1732584194; - let d = 271733878; - for (let i = 0; i < x.length; i += 16) { - const olda = a; - const oldb = b; - const oldc = c; - const oldd = d; - a = md5ff(a, b, c, d, x[i], 7, -680876936); - d = md5ff(d, a, b, c, x[i + 1], 12, -389564586); - c = md5ff(c, d, a, b, x[i + 2], 17, 606105819); - b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330); - a = md5ff(a, b, c, d, x[i + 4], 7, -176418897); - d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426); - c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341); - b = md5ff(b, c, d, a, x[i + 7], 22, -45705983); - a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416); - d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417); - c = md5ff(c, d, a, b, x[i + 10], 17, -42063); - b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162); - a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682); - d = md5ff(d, a, b, c, x[i + 13], 12, -40341101); - c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290); - b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329); - a = md5gg(a, b, c, d, x[i + 1], 5, -165796510); - d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632); - c = md5gg(c, d, a, b, x[i + 11], 14, 643717713); - b = md5gg(b, c, d, a, x[i], 20, -373897302); - a = md5gg(a, b, c, d, x[i + 5], 5, -701558691); - d = md5gg(d, a, b, c, x[i + 10], 9, 38016083); - c = md5gg(c, d, a, b, x[i + 15], 14, -660478335); - b = md5gg(b, c, d, a, x[i + 4], 20, -405537848); - a = md5gg(a, b, c, d, x[i + 9], 5, 568446438); - d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690); - c = md5gg(c, d, a, b, x[i + 3], 14, -187363961); - b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501); - a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467); - d = md5gg(d, a, b, c, x[i + 2], 9, -51403784); - c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473); - b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734); - a = md5hh(a, b, c, d, x[i + 5], 4, -378558); - d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463); - c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562); - b = md5hh(b, c, d, a, x[i + 14], 23, -35309556); - a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060); - d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353); - c = md5hh(c, d, a, b, x[i + 7], 16, -155497632); - b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640); - a = md5hh(a, b, c, d, x[i + 13], 4, 681279174); - d = md5hh(d, a, b, c, x[i], 11, -358537222); - c = md5hh(c, d, a, b, x[i + 3], 16, -722521979); - b = md5hh(b, c, d, a, x[i + 6], 23, 76029189); - a = md5hh(a, b, c, d, x[i + 9], 4, -640364487); - d = md5hh(d, a, b, c, x[i + 12], 11, -421815835); - c = md5hh(c, d, a, b, x[i + 15], 16, 530742520); - b = md5hh(b, c, d, a, x[i + 2], 23, -995338651); - a = md5ii(a, b, c, d, x[i], 6, -198630844); - d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415); - c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905); - b = md5ii(b, c, d, a, x[i + 5], 21, -57434055); - a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571); - d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606); - c = md5ii(c, d, a, b, x[i + 10], 15, -1051523); - b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799); - a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359); - d = md5ii(d, a, b, c, x[i + 15], 10, -30611744); - c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380); - b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649); - a = md5ii(a, b, c, d, x[i + 4], 6, -145523070); - d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379); - c = md5ii(c, d, a, b, x[i + 2], 15, 718787259); - b = md5ii(b, c, d, a, x[i + 9], 21, -343485551); - a = safeAdd(a, olda); - b = safeAdd(b, oldb); - c = safeAdd(c, oldc); - d = safeAdd(d, oldd); - } - return [a, b, c, d]; -} - -/* - * Convert an array bytes to an array of little-endian words - * Characters >255 have their high-byte silently ignored. - */ -function bytesToWords(input) { - if (input.length === 0) { - return []; - } - const length8 = input.length * 8; - const output = new Uint32Array(getOutputLength(length8)); - for (let i = 0; i < length8; i += 8) { - output[i >> 5] |= (input[i / 8] & 0xff) << i % 32; - } - return output; -} - -/* - * Add integers, wrapping at 2^32. This uses 16-bit operations internally - * to work around bugs in some JS interpreters. - */ -function safeAdd(x, y) { - const lsw = (x & 0xffff) + (y & 0xffff); - const msw = (x >> 16) + (y >> 16) + (lsw >> 16); - return msw << 16 | lsw & 0xffff; -} - -/* - * Bitwise rotate a 32-bit number to the left. - */ -function bitRotateLeft(num, cnt) { - return num << cnt | num >>> 32 - cnt; -} - -/* - * These functions implement the four basic operations the algorithm uses. - */ -function md5cmn(q, a, b, x, s, t) { - return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b); -} -function md5ff(a, b, c, d, x, s, t) { - return md5cmn(b & c | ~b & d, a, b, x, s, t); -} -function md5gg(a, b, c, d, x, s, t) { - return md5cmn(b & d | c & ~d, a, b, x, s, t); -} -function md5hh(a, b, c, d, x, s, t) { - return md5cmn(b ^ c ^ d, a, b, x, s, t); -} -function md5ii(a, b, c, d, x, s, t) { - return md5cmn(c ^ (b | ~d), a, b, x, s, t); -} -var _default = exports.default = md5; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/md5.js b/static/node_modules/uuid/dist/md5.js index 135b24d..918be8c 100644 --- a/static/node_modules/uuid/dist/md5.js +++ b/static/node_modules/uuid/dist/md5.js @@ -1,17 +1,135 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _nodeCrypto = _interopRequireDefault(require("node:crypto")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } function md5(bytes) { - if (Array.isArray(bytes)) { - bytes = Buffer.from(bytes); - } else if (typeof bytes === 'string') { - bytes = Buffer.from(bytes, 'utf8'); - } - return _nodeCrypto.default.createHash('md5').update(bytes).digest(); + const words = uint8ToUint32(bytes); + const md5Bytes = wordsToMd5(words, bytes.length * 8); + return uint32ToUint8(md5Bytes); } -var _default = exports.default = md5; \ No newline at end of file +function uint32ToUint8(input) { + const bytes = new Uint8Array(input.length * 4); + for (let i = 0; i < input.length * 4; i++) { + bytes[i] = (input[i >> 2] >>> ((i % 4) * 8)) & 0xff; + } + return bytes; +} +function getOutputLength(inputLength8) { + return (((inputLength8 + 64) >>> 9) << 4) + 14 + 1; +} +function wordsToMd5(x, len) { + const xpad = new Uint32Array(getOutputLength(len)).fill(0); + xpad.set(x); + xpad[len >> 5] |= 0x80 << len % 32; + xpad[xpad.length - 1] = len; + x = xpad; + let a = 1732584193; + let b = -271733879; + let c = -1732584194; + let d = 271733878; + for (let i = 0; i < x.length; i += 16) { + const olda = a; + const oldb = b; + const oldc = c; + const oldd = d; + a = md5ff(a, b, c, d, x[i], 7, -680876936); + d = md5ff(d, a, b, c, x[i + 1], 12, -389564586); + c = md5ff(c, d, a, b, x[i + 2], 17, 606105819); + b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330); + a = md5ff(a, b, c, d, x[i + 4], 7, -176418897); + d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426); + c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341); + b = md5ff(b, c, d, a, x[i + 7], 22, -45705983); + a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416); + d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417); + c = md5ff(c, d, a, b, x[i + 10], 17, -42063); + b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162); + a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682); + d = md5ff(d, a, b, c, x[i + 13], 12, -40341101); + c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290); + b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329); + a = md5gg(a, b, c, d, x[i + 1], 5, -165796510); + d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632); + c = md5gg(c, d, a, b, x[i + 11], 14, 643717713); + b = md5gg(b, c, d, a, x[i], 20, -373897302); + a = md5gg(a, b, c, d, x[i + 5], 5, -701558691); + d = md5gg(d, a, b, c, x[i + 10], 9, 38016083); + c = md5gg(c, d, a, b, x[i + 15], 14, -660478335); + b = md5gg(b, c, d, a, x[i + 4], 20, -405537848); + a = md5gg(a, b, c, d, x[i + 9], 5, 568446438); + d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690); + c = md5gg(c, d, a, b, x[i + 3], 14, -187363961); + b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501); + a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467); + d = md5gg(d, a, b, c, x[i + 2], 9, -51403784); + c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473); + b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734); + a = md5hh(a, b, c, d, x[i + 5], 4, -378558); + d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463); + c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562); + b = md5hh(b, c, d, a, x[i + 14], 23, -35309556); + a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060); + d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353); + c = md5hh(c, d, a, b, x[i + 7], 16, -155497632); + b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640); + a = md5hh(a, b, c, d, x[i + 13], 4, 681279174); + d = md5hh(d, a, b, c, x[i], 11, -358537222); + c = md5hh(c, d, a, b, x[i + 3], 16, -722521979); + b = md5hh(b, c, d, a, x[i + 6], 23, 76029189); + a = md5hh(a, b, c, d, x[i + 9], 4, -640364487); + d = md5hh(d, a, b, c, x[i + 12], 11, -421815835); + c = md5hh(c, d, a, b, x[i + 15], 16, 530742520); + b = md5hh(b, c, d, a, x[i + 2], 23, -995338651); + a = md5ii(a, b, c, d, x[i], 6, -198630844); + d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415); + c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905); + b = md5ii(b, c, d, a, x[i + 5], 21, -57434055); + a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571); + d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606); + c = md5ii(c, d, a, b, x[i + 10], 15, -1051523); + b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799); + a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359); + d = md5ii(d, a, b, c, x[i + 15], 10, -30611744); + c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380); + b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649); + a = md5ii(a, b, c, d, x[i + 4], 6, -145523070); + d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379); + c = md5ii(c, d, a, b, x[i + 2], 15, 718787259); + b = md5ii(b, c, d, a, x[i + 9], 21, -343485551); + a = safeAdd(a, olda); + b = safeAdd(b, oldb); + c = safeAdd(c, oldc); + d = safeAdd(d, oldd); + } + return Uint32Array.of(a, b, c, d); +} +function uint8ToUint32(input) { + if (input.length === 0) { + return new Uint32Array(); + } + const output = new Uint32Array(getOutputLength(input.length * 8)).fill(0); + for (let i = 0; i < input.length; i++) { + output[i >> 2] |= (input[i] & 0xff) << ((i % 4) * 8); + } + return output; +} +function safeAdd(x, y) { + const lsw = (x & 0xffff) + (y & 0xffff); + const msw = (x >> 16) + (y >> 16) + (lsw >> 16); + return (msw << 16) | (lsw & 0xffff); +} +function bitRotateLeft(num, cnt) { + return (num << cnt) | (num >>> (32 - cnt)); +} +function md5cmn(q, a, b, x, s, t) { + return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b); +} +function md5ff(a, b, c, d, x, s, t) { + return md5cmn((b & c) | (~b & d), a, b, x, s, t); +} +function md5gg(a, b, c, d, x, s, t) { + return md5cmn((b & d) | (c & ~d), a, b, x, s, t); +} +function md5hh(a, b, c, d, x, s, t) { + return md5cmn(b ^ c ^ d, a, b, x, s, t); +} +function md5ii(a, b, c, d, x, s, t) { + return md5cmn(c ^ (b | ~d), a, b, x, s, t); +} +export default md5; diff --git a/static/node_modules/uuid/dist/native-browser.js b/static/node_modules/uuid/dist/native-browser.js deleted file mode 100644 index bc5d383..0000000 --- a/static/node_modules/uuid/dist/native-browser.js +++ /dev/null @@ -1,10 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto); -var _default = exports.default = { - randomUUID -}; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/native.js b/static/node_modules/uuid/dist/native.js index 4c273c5..76f44f9 100644 --- a/static/node_modules/uuid/dist/native.js +++ b/static/node_modules/uuid/dist/native.js @@ -1,11 +1,2 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _nodeCrypto = _interopRequireDefault(require("node:crypto")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -var _default = exports.default = { - randomUUID: _nodeCrypto.default.randomUUID -}; \ No newline at end of file +const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto); +export default { randomUUID }; diff --git a/static/node_modules/uuid/dist/nil.js b/static/node_modules/uuid/dist/nil.js index f7967e9..de6f830 100644 --- a/static/node_modules/uuid/dist/nil.js +++ b/static/node_modules/uuid/dist/nil.js @@ -1,7 +1 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _default = exports.default = '00000000-0000-0000-0000-000000000000'; \ No newline at end of file +export default '00000000-0000-0000-0000-000000000000'; diff --git a/static/node_modules/uuid/dist/parse.js b/static/node_modules/uuid/dist/parse.js index 1707c90..64ac401 100644 --- a/static/node_modules/uuid/dist/parse.js +++ b/static/node_modules/uuid/dist/parse.js @@ -1,44 +1,9 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _validate = _interopRequireDefault(require("./validate.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } +import validate from './validate.js'; function parse(uuid) { - if (!(0, _validate.default)(uuid)) { - throw TypeError('Invalid UUID'); - } - let v; - const arr = new Uint8Array(16); - - // Parse ########-....-....-....-............ - arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24; - arr[1] = v >>> 16 & 0xff; - arr[2] = v >>> 8 & 0xff; - arr[3] = v & 0xff; - - // Parse ........-####-....-....-............ - arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8; - arr[5] = v & 0xff; - - // Parse ........-....-####-....-............ - arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8; - arr[7] = v & 0xff; - - // Parse ........-....-....-####-............ - arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8; - arr[9] = v & 0xff; - - // Parse ........-....-....-....-############ - // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes) - arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff; - arr[11] = v / 0x100000000 & 0xff; - arr[12] = v >>> 24 & 0xff; - arr[13] = v >>> 16 & 0xff; - arr[14] = v >>> 8 & 0xff; - arr[15] = v & 0xff; - return arr; + if (!validate(uuid)) { + throw TypeError('Invalid UUID'); + } + let v; + return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, (v >>> 16) & 0xff, (v >>> 8) & 0xff, v & 0xff, (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 0xff, (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 0xff, (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 0xff, ((v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000) & 0xff, (v / 0x100000000) & 0xff, (v >>> 24) & 0xff, (v >>> 16) & 0xff, (v >>> 8) & 0xff, v & 0xff); } -var _default = exports.default = parse; \ No newline at end of file +export default parse; diff --git a/static/node_modules/uuid/dist/regex.js b/static/node_modules/uuid/dist/regex.js index fc02a88..3e38591 100644 --- a/static/node_modules/uuid/dist/regex.js +++ b/static/node_modules/uuid/dist/regex.js @@ -1,7 +1 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _default = exports.default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i; \ No newline at end of file +export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i; diff --git a/static/node_modules/uuid/dist/rng-browser.js b/static/node_modules/uuid/dist/rng-browser.js deleted file mode 100644 index e257738..0000000 --- a/static/node_modules/uuid/dist/rng-browser.js +++ /dev/null @@ -1,23 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = rng; -// Unique ID creation requires a high quality random # generator. In the browser we therefore -// require the crypto API and do not support built-in fallback to lower quality random number -// generators (like Math.random()). - -let getRandomValues; -const rnds8 = new Uint8Array(16); -function rng() { - // lazy load so that environments that need to polyfill have a chance to do so - if (!getRandomValues) { - // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. - getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto); - if (!getRandomValues) { - throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported'); - } - } - return getRandomValues(rnds8); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/rng.js b/static/node_modules/uuid/dist/rng.js index f5eb9a1..770f2e2 100644 --- a/static/node_modules/uuid/dist/rng.js +++ b/static/node_modules/uuid/dist/rng.js @@ -1,17 +1,11 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = rng; -var _nodeCrypto = _interopRequireDefault(require("node:crypto")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate -let poolPtr = rnds8Pool.length; -function rng() { - if (poolPtr > rnds8Pool.length - 16) { - _nodeCrypto.default.randomFillSync(rnds8Pool); - poolPtr = 0; - } - return rnds8Pool.slice(poolPtr, poolPtr += 16); -} \ No newline at end of file +let getRandomValues; +const rnds8 = new Uint8Array(16); +export default function rng() { + if (!getRandomValues) { + if (typeof crypto === 'undefined' || !crypto.getRandomValues) { + throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported'); + } + getRandomValues = crypto.getRandomValues.bind(crypto); + } + return getRandomValues(rnds8); +} diff --git a/static/node_modules/uuid/dist/sha1-browser.js b/static/node_modules/uuid/dist/sha1-browser.js deleted file mode 100644 index ded98db..0000000 --- a/static/node_modules/uuid/dist/sha1-browser.js +++ /dev/null @@ -1,82 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -// Adapted from Chris Veness' SHA1 code at -// http://www.movable-type.co.uk/scripts/sha1.html -function f(s, x, y, z) { - switch (s) { - case 0: - return x & y ^ ~x & z; - case 1: - return x ^ y ^ z; - case 2: - return x & y ^ x & z ^ y & z; - case 3: - return x ^ y ^ z; - } -} -function ROTL(x, n) { - return x << n | x >>> 32 - n; -} -function sha1(bytes) { - const K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6]; - const H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]; - if (typeof bytes === 'string') { - const msg = unescape(encodeURIComponent(bytes)); // UTF8 escape - - bytes = []; - for (let i = 0; i < msg.length; ++i) { - bytes.push(msg.charCodeAt(i)); - } - } else if (!Array.isArray(bytes)) { - // Convert Array-like to Array - bytes = Array.prototype.slice.call(bytes); - } - bytes.push(0x80); - const l = bytes.length / 4 + 2; - const N = Math.ceil(l / 16); - const M = new Array(N); - for (let i = 0; i < N; ++i) { - const arr = new Uint32Array(16); - for (let j = 0; j < 16; ++j) { - arr[j] = bytes[i * 64 + j * 4] << 24 | bytes[i * 64 + j * 4 + 1] << 16 | bytes[i * 64 + j * 4 + 2] << 8 | bytes[i * 64 + j * 4 + 3]; - } - M[i] = arr; - } - M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32); - M[N - 1][14] = Math.floor(M[N - 1][14]); - M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff; - for (let i = 0; i < N; ++i) { - const W = new Uint32Array(80); - for (let t = 0; t < 16; ++t) { - W[t] = M[i][t]; - } - for (let t = 16; t < 80; ++t) { - W[t] = ROTL(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1); - } - let a = H[0]; - let b = H[1]; - let c = H[2]; - let d = H[3]; - let e = H[4]; - for (let t = 0; t < 80; ++t) { - const s = Math.floor(t / 20); - const T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[t] >>> 0; - e = d; - d = c; - c = ROTL(b, 30) >>> 0; - b = a; - a = T; - } - H[0] = H[0] + a >>> 0; - H[1] = H[1] + b >>> 0; - H[2] = H[2] + c >>> 0; - H[3] = H[3] + d >>> 0; - H[4] = H[4] + e >>> 0; - } - return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff]; -} -var _default = exports.default = sha1; \ No newline at end of file diff --git a/static/node_modules/uuid/dist/sha1.js b/static/node_modules/uuid/dist/sha1.js index 3b9ded9..dbb78ae 100644 --- a/static/node_modules/uuid/dist/sha1.js +++ b/static/node_modules/uuid/dist/sha1.js @@ -1,17 +1,70 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _nodeCrypto = _interopRequireDefault(require("node:crypto")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -function sha1(bytes) { - if (Array.isArray(bytes)) { - bytes = Buffer.from(bytes); - } else if (typeof bytes === 'string') { - bytes = Buffer.from(bytes, 'utf8'); - } - return _nodeCrypto.default.createHash('sha1').update(bytes).digest(); +function f(s, x, y, z) { + switch (s) { + case 0: + return (x & y) ^ (~x & z); + case 1: + return x ^ y ^ z; + case 2: + return (x & y) ^ (x & z) ^ (y & z); + case 3: + return x ^ y ^ z; + } } -var _default = exports.default = sha1; \ No newline at end of file +function ROTL(x, n) { + return (x << n) | (x >>> (32 - n)); +} +function sha1(bytes) { + const K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6]; + const H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]; + const newBytes = new Uint8Array(bytes.length + 1); + newBytes.set(bytes); + newBytes[bytes.length] = 0x80; + bytes = newBytes; + const l = bytes.length / 4 + 2; + const N = Math.ceil(l / 16); + const M = new Array(N); + for (let i = 0; i < N; ++i) { + const arr = new Uint32Array(16); + for (let j = 0; j < 16; ++j) { + arr[j] = + (bytes[i * 64 + j * 4] << 24) | + (bytes[i * 64 + j * 4 + 1] << 16) | + (bytes[i * 64 + j * 4 + 2] << 8) | + bytes[i * 64 + j * 4 + 3]; + } + M[i] = arr; + } + M[N - 1][14] = ((bytes.length - 1) * 8) / Math.pow(2, 32); + M[N - 1][14] = Math.floor(M[N - 1][14]); + M[N - 1][15] = ((bytes.length - 1) * 8) & 0xffffffff; + for (let i = 0; i < N; ++i) { + const W = new Uint32Array(80); + for (let t = 0; t < 16; ++t) { + W[t] = M[i][t]; + } + for (let t = 16; t < 80; ++t) { + W[t] = ROTL(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1); + } + let a = H[0]; + let b = H[1]; + let c = H[2]; + let d = H[3]; + let e = H[4]; + for (let t = 0; t < 80; ++t) { + const s = Math.floor(t / 20); + const T = (ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[t]) >>> 0; + e = d; + d = c; + c = ROTL(b, 30) >>> 0; + b = a; + a = T; + } + H[0] = (H[0] + a) >>> 0; + H[1] = (H[1] + b) >>> 0; + H[2] = (H[2] + c) >>> 0; + H[3] = (H[3] + d) >>> 0; + H[4] = (H[4] + e) >>> 0; + } + return Uint8Array.of(H[0] >> 24, H[0] >> 16, H[0] >> 8, H[0], H[1] >> 24, H[1] >> 16, H[1] >> 8, H[1], H[2] >> 24, H[2] >> 16, H[2] >> 8, H[2], H[3] >> 24, H[3] >> 16, H[3] >> 8, H[3], H[4] >> 24, H[4] >> 16, H[4] >> 8, H[4]); +} +export default sha1; diff --git a/static/node_modules/uuid/dist/stringify.js b/static/node_modules/uuid/dist/stringify.js index 2522dc9..962738c 100644 --- a/static/node_modules/uuid/dist/stringify.js +++ b/static/node_modules/uuid/dist/stringify.js @@ -1,38 +1,35 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -exports.unsafeStringify = unsafeStringify; -var _validate = _interopRequireDefault(require("./validate.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -/** - * Convert array of 16 byte values to UUID string format of the form: - * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX - */ +import validate from './validate.js'; const byteToHex = []; for (let i = 0; i < 256; ++i) { - byteToHex.push((i + 0x100).toString(16).slice(1)); + byteToHex.push((i + 0x100).toString(16).slice(1)); } -function unsafeStringify(arr, offset = 0) { - // Note: Be careful editing this code! It's been tuned for performance - // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 - // - // Note to future-self: No, you can't remove the `toLowerCase()` call. - // REF: https://github.com/uuidjs/uuid/pull/677#issuecomment-1757351351 - return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); +export function unsafeStringify(arr, offset = 0) { + return (byteToHex[arr[offset + 0]] + + byteToHex[arr[offset + 1]] + + byteToHex[arr[offset + 2]] + + byteToHex[arr[offset + 3]] + + '-' + + byteToHex[arr[offset + 4]] + + byteToHex[arr[offset + 5]] + + '-' + + byteToHex[arr[offset + 6]] + + byteToHex[arr[offset + 7]] + + '-' + + byteToHex[arr[offset + 8]] + + byteToHex[arr[offset + 9]] + + '-' + + byteToHex[arr[offset + 10]] + + byteToHex[arr[offset + 11]] + + byteToHex[arr[offset + 12]] + + byteToHex[arr[offset + 13]] + + byteToHex[arr[offset + 14]] + + byteToHex[arr[offset + 15]]).toLowerCase(); } function stringify(arr, offset = 0) { - const uuid = unsafeStringify(arr, offset); - // Consistency check for valid UUID. If this throws, it's likely due to one - // of the following: - // - One or more input array values don't map to a hex octet (leading to - // "undefined" in the uuid) - // - Invalid input values for the RFC `version` or `variant` fields - if (!(0, _validate.default)(uuid)) { - throw TypeError('Stringified UUID is invalid'); - } - return uuid; + const uuid = unsafeStringify(arr, offset); + if (!validate(uuid)) { + throw TypeError('Stringified UUID is invalid'); + } + return uuid; } -var _default = exports.default = stringify; \ No newline at end of file +export default stringify; diff --git a/static/node_modules/uuid/dist/uuid-bin.js b/static/node_modules/uuid/dist/uuid-bin.js index d039dfe..aa4d4ac 100644 --- a/static/node_modules/uuid/dist/uuid-bin.js +++ b/static/node_modules/uuid/dist/uuid-bin.js @@ -1,75 +1,70 @@ -"use strict"; - -var _assert = _interopRequireDefault(require("assert")); -var _v = _interopRequireDefault(require("./v1.js")); -var _v2 = _interopRequireDefault(require("./v3.js")); -var _v3 = _interopRequireDefault(require("./v4.js")); -var _v4 = _interopRequireDefault(require("./v5.js")); -var _v5 = _interopRequireDefault(require("./v6.js")); -var _v6 = _interopRequireDefault(require("./v7.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } +import * as assert from 'node:assert/strict'; +import v1 from './v1.js'; +import v3 from './v3.js'; +import v4 from './v4.js'; +import v5 from './v5.js'; +import v6 from './v6.js'; +import v7 from './v7.js'; function usage() { - console.log('Usage:'); - console.log(' uuid'); - console.log(' uuid v1'); - console.log(' uuid v3 '); - console.log(' uuid v4'); - console.log(' uuid v5 '); - console.log(' uuid v6'); - console.log(' uuid v7'); - console.log(' uuid --help'); - console.log('\nNote: may be "URL" or "DNS" to use the corresponding UUIDs defined by RFC9562'); + console.log('Usage:'); + console.log(' uuid'); + console.log(' uuid v1'); + console.log(' uuid v3 '); + console.log(' uuid v4'); + console.log(' uuid v5 '); + console.log(' uuid v6'); + console.log(' uuid v7'); + console.log(' uuid --help'); + console.log('\nNote: may be "URL" or "DNS" to use the corresponding UUIDs defined by RFC9562'); } const args = process.argv.slice(2); if (args.indexOf('--help') >= 0) { - usage(); - process.exit(0); + usage(); + process.exit(0); } const version = args.shift() || 'v4'; switch (version) { - case 'v1': - console.log((0, _v.default)()); - break; - case 'v3': - { - const name = args.shift(); - let namespace = args.shift(); - (0, _assert.default)(name != null, 'v3 name not specified'); - (0, _assert.default)(namespace != null, 'v3 namespace not specified'); - if (namespace === 'URL') { - namespace = _v2.default.URL; - } - if (namespace === 'DNS') { - namespace = _v2.default.DNS; - } - console.log((0, _v2.default)(name, namespace)); - break; + case 'v1': + console.log(v1()); + break; + case 'v3': { + const name = args.shift(); + let namespace = args.shift(); + assert.ok(name != null, 'v3 name not specified'); + assert.ok(namespace != null, 'v3 namespace not specified'); + if (namespace === 'URL') { + namespace = v3.URL; + } + if (namespace === 'DNS') { + namespace = v3.DNS; + } + console.log(v3(name, namespace)); + break; } - case 'v4': - console.log((0, _v3.default)()); - break; - case 'v5': - { - const name = args.shift(); - let namespace = args.shift(); - (0, _assert.default)(name != null, 'v5 name not specified'); - (0, _assert.default)(namespace != null, 'v5 namespace not specified'); - if (namespace === 'URL') { - namespace = _v4.default.URL; - } - if (namespace === 'DNS') { - namespace = _v4.default.DNS; - } - console.log((0, _v4.default)(name, namespace)); - break; + case 'v4': + console.log(v4()); + break; + case 'v5': { + const name = args.shift(); + let namespace = args.shift(); + assert.ok(name != null, 'v5 name not specified'); + assert.ok(namespace != null, 'v5 namespace not specified'); + if (namespace === 'URL') { + namespace = v5.URL; + } + if (namespace === 'DNS') { + namespace = v5.DNS; + } + console.log(v5(name, namespace)); + break; } - case 'v6': - console.log((0, _v5.default)()); - break; - case 'v7': - console.log((0, _v6.default)()); - break; - default: - usage(); - process.exit(1); -} \ No newline at end of file + case 'v6': + console.log(v6()); + break; + case 'v7': + console.log(v7()); + break; + default: + usage(); + process.exit(1); +} diff --git a/static/node_modules/uuid/dist/v1.js b/static/node_modules/uuid/dist/v1.js index c6b9344..65e3f68 100644 --- a/static/node_modules/uuid/dist/v1.js +++ b/static/node_modules/uuid/dist/v1.js @@ -1,131 +1,83 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _rng = _interopRequireDefault(require("./rng.js")); -var _stringify = require("./stringify.js"); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -// **`v1()` - Generate time-based UUID** -// -// Inspired by https://github.com/LiosK/UUID.js -// and http://docs.python.org/library/uuid.html - -let _nodeId; -let _clockseq; - -// Previous uuid creation time -let _lastMSecs = 0; -let _lastNSecs = 0; - -// See https://github.com/uuidjs/uuid for API details +import rng from './rng.js'; +import { unsafeStringify } from './stringify.js'; +const _state = {}; function v1(options, buf, offset) { - let i = buf && offset || 0; - const b = buf || new Array(16); - options = options || {}; - let node = options.node; - let clockseq = options.clockseq; - - // v1 only: Use cached `node` and `clockseq` values - if (!options._v6) { - if (!node) { - node = _nodeId; + let bytes; + const isV6 = options?._v6 ?? false; + if (options) { + const optionsKeys = Object.keys(options); + if (optionsKeys.length === 1 && optionsKeys[0] === '_v6') { + options = undefined; + } } - if (clockseq == null) { - clockseq = _clockseq; + if (options) { + bytes = v1Bytes(options.random ?? options.rng?.() ?? rng(), options.msecs, options.nsecs, options.clockseq, options.node, buf, offset); } - } - - // Handle cases where we need entropy. We do this lazily to minimize issues - // related to insufficient system entropy. See #189 - if (node == null || clockseq == null) { - const seedBytes = options.random || (options.rng || _rng.default)(); - - // Randomize node - if (node == null) { - node = [seedBytes[0], seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]]; - - // v1 only: cache node value for reuse - if (!_nodeId && !options._v6) { - // per RFC4122 4.5: Set MAC multicast bit (v1 only) - node[0] |= 0x01; // Set multicast bit - - _nodeId = node; - } + else { + const now = Date.now(); + const rnds = rng(); + updateV1State(_state, now, rnds); + bytes = v1Bytes(rnds, _state.msecs, _state.nsecs, isV6 ? undefined : _state.clockseq, isV6 ? undefined : _state.node, buf, offset); } - - // Randomize clockseq - if (clockseq == null) { - // Per 4.2.2, randomize (14 bit) clockseq - clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; - if (_clockseq === undefined && !options._v6) { - _clockseq = clockseq; - } - } - } - - // v1 & v6 timestamps are 100 nano-second units since the Gregorian epoch, - // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so time is - // handled internally as 'msecs' (integer milliseconds) and 'nsecs' - // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. - let msecs = options.msecs !== undefined ? options.msecs : Date.now(); - - // Per 4.2.1.2, use count of uuid's generated during the current clock - // cycle to simulate higher resolution clock - let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; - - // Time since last uuid creation (in msecs) - const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; - - // Per 4.2.1.2, Bump clockseq on clock regression - if (dt < 0 && options.clockseq === undefined) { - clockseq = clockseq + 1 & 0x3fff; - } - - // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new - // time interval - if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { - nsecs = 0; - } - - // Per 4.2.1.2 Throw error if too many uuids are requested - if (nsecs >= 10000) { - throw new Error("uuid.v1(): Can't create more than 10M uuids/sec"); - } - _lastMSecs = msecs; - _lastNSecs = nsecs; - _clockseq = clockseq; - - // Per 4.1.4 - Convert from unix epoch to Gregorian epoch - msecs += 12219292800000; - - // `time_low` - const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; - b[i++] = tl >>> 24 & 0xff; - b[i++] = tl >>> 16 & 0xff; - b[i++] = tl >>> 8 & 0xff; - b[i++] = tl & 0xff; - - // `time_mid` - const tmh = msecs / 0x100000000 * 10000 & 0xfffffff; - b[i++] = tmh >>> 8 & 0xff; - b[i++] = tmh & 0xff; - - // `time_high_and_version` - b[i++] = tmh >>> 24 & 0xf | 0x10; // include version - b[i++] = tmh >>> 16 & 0xff; - - // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) - b[i++] = clockseq >>> 8 | 0x80; - - // `clock_seq_low` - b[i++] = clockseq & 0xff; - - // `node` - for (let n = 0; n < 6; ++n) { - b[i + n] = node[n]; - } - return buf || (0, _stringify.unsafeStringify)(b); + return buf ?? unsafeStringify(bytes); } -var _default = exports.default = v1; \ No newline at end of file +export function updateV1State(state, now, rnds) { + state.msecs ??= -Infinity; + state.nsecs ??= 0; + if (now === state.msecs) { + state.nsecs++; + if (state.nsecs >= 10000) { + state.node = undefined; + state.nsecs = 0; + } + } + else if (now > state.msecs) { + state.nsecs = 0; + } + else if (now < state.msecs) { + state.node = undefined; + } + if (!state.node) { + state.node = rnds.slice(10, 16); + state.node[0] |= 0x01; + state.clockseq = ((rnds[8] << 8) | rnds[9]) & 0x3fff; + } + state.msecs = now; + return state; +} +function v1Bytes(rnds, msecs, nsecs, clockseq, node, buf, offset = 0) { + if (rnds.length < 16) { + throw new Error('Random bytes length must be >= 16'); + } + if (!buf) { + buf = new Uint8Array(16); + offset = 0; + } + else { + if (offset < 0 || offset + 16 > buf.length) { + throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`); + } + } + msecs ??= Date.now(); + nsecs ??= 0; + clockseq ??= ((rnds[8] << 8) | rnds[9]) & 0x3fff; + node ??= rnds.slice(10, 16); + msecs += 12219292800000; + const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; + buf[offset++] = (tl >>> 24) & 0xff; + buf[offset++] = (tl >>> 16) & 0xff; + buf[offset++] = (tl >>> 8) & 0xff; + buf[offset++] = tl & 0xff; + const tmh = ((msecs / 0x100000000) * 10000) & 0xfffffff; + buf[offset++] = (tmh >>> 8) & 0xff; + buf[offset++] = tmh & 0xff; + buf[offset++] = ((tmh >>> 24) & 0xf) | 0x10; + buf[offset++] = (tmh >>> 16) & 0xff; + buf[offset++] = (clockseq >>> 8) | 0x80; + buf[offset++] = clockseq & 0xff; + for (let n = 0; n < 6; ++n) { + buf[offset++] = node[n]; + } + return buf; +} +export default v1; diff --git a/static/node_modules/uuid/dist/v1ToV6.js b/static/node_modules/uuid/dist/v1ToV6.js index ce56373..da0f763 100644 --- a/static/node_modules/uuid/dist/v1ToV6.js +++ b/static/node_modules/uuid/dist/v1ToV6.js @@ -1,26 +1,10 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = v1ToV6; -var _parse = _interopRequireDefault(require("./parse.js")); -var _stringify = require("./stringify.js"); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -/** - * Convert a v1 UUID to a v6 UUID - * - * @param {string|Uint8Array} uuid - The v1 UUID to convert to v6 - * @returns {string|Uint8Array} The v6 UUID as the same type as the `uuid` arg - * (string or Uint8Array) - */ -function v1ToV6(uuid) { - const v1Bytes = typeof uuid === 'string' ? (0, _parse.default)(uuid) : uuid; - const v6Bytes = _v1ToV6(v1Bytes); - return typeof uuid === 'string' ? (0, _stringify.unsafeStringify)(v6Bytes) : v6Bytes; +import parse from './parse.js'; +import { unsafeStringify } from './stringify.js'; +export default function v1ToV6(uuid) { + const v1Bytes = typeof uuid === 'string' ? parse(uuid) : uuid; + const v6Bytes = _v1ToV6(v1Bytes); + return typeof uuid === 'string' ? unsafeStringify(v6Bytes) : v6Bytes; +} +function _v1ToV6(v1Bytes) { + return Uint8Array.of(((v1Bytes[6] & 0x0f) << 4) | ((v1Bytes[7] >> 4) & 0x0f), ((v1Bytes[7] & 0x0f) << 4) | ((v1Bytes[4] & 0xf0) >> 4), ((v1Bytes[4] & 0x0f) << 4) | ((v1Bytes[5] & 0xf0) >> 4), ((v1Bytes[5] & 0x0f) << 4) | ((v1Bytes[0] & 0xf0) >> 4), ((v1Bytes[0] & 0x0f) << 4) | ((v1Bytes[1] & 0xf0) >> 4), ((v1Bytes[1] & 0x0f) << 4) | ((v1Bytes[2] & 0xf0) >> 4), 0x60 | (v1Bytes[2] & 0x0f), v1Bytes[3], v1Bytes[8], v1Bytes[9], v1Bytes[10], v1Bytes[11], v1Bytes[12], v1Bytes[13], v1Bytes[14], v1Bytes[15]); } - -// Do the field transformation needed for v1 -> v6 -function _v1ToV6(v1Bytes, randomize = false) { - return Uint8Array.of((v1Bytes[6] & 0x0f) << 4 | v1Bytes[7] >> 4 & 0x0f, (v1Bytes[7] & 0x0f) << 4 | (v1Bytes[4] & 0xf0) >> 4, (v1Bytes[4] & 0x0f) << 4 | (v1Bytes[5] & 0xf0) >> 4, (v1Bytes[5] & 0x0f) << 4 | (v1Bytes[0] & 0xf0) >> 4, (v1Bytes[0] & 0x0f) << 4 | (v1Bytes[1] & 0xf0) >> 4, (v1Bytes[1] & 0x0f) << 4 | (v1Bytes[2] & 0xf0) >> 4, 0x60 | v1Bytes[2] & 0x0f, v1Bytes[3], v1Bytes[8], v1Bytes[9], v1Bytes[10], v1Bytes[11], v1Bytes[12], v1Bytes[13], v1Bytes[14], v1Bytes[15]); -} \ No newline at end of file diff --git a/static/node_modules/uuid/dist/v3.js b/static/node_modules/uuid/dist/v3.js index a3eed7e..b5c3781 100644 --- a/static/node_modules/uuid/dist/v3.js +++ b/static/node_modules/uuid/dist/v3.js @@ -1,11 +1,9 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _v = _interopRequireDefault(require("./v35.js")); -var _md = _interopRequireDefault(require("./md5.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -const v3 = (0, _v.default)('v3', 0x30, _md.default); -var _default = exports.default = v3; \ No newline at end of file +import md5 from './md5.js'; +import v35, { DNS, URL } from './v35.js'; +export { DNS, URL } from './v35.js'; +function v3(value, namespace, buf, offset) { + return v35(0x30, md5, value, namespace, buf, offset); +} +v3.DNS = DNS; +v3.URL = URL; +export default v3; diff --git a/static/node_modules/uuid/dist/v35.js b/static/node_modules/uuid/dist/v35.js index f2e35ae..2e02842 100644 --- a/static/node_modules/uuid/dist/v35.js +++ b/static/node_modules/uuid/dist/v35.js @@ -1,63 +1,39 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.URL = exports.DNS = void 0; -exports.default = v35; -var _stringify = require("./stringify.js"); -var _parse = _interopRequireDefault(require("./parse.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -function stringToBytes(str) { - str = unescape(encodeURIComponent(str)); // UTF8 escape - - const bytes = []; - for (let i = 0; i < str.length; ++i) { - bytes.push(str.charCodeAt(i)); - } - return bytes; +import parse from './parse.js'; +import { unsafeStringify } from './stringify.js'; +export function stringToBytes(str) { + str = unescape(encodeURIComponent(str)); + const bytes = new Uint8Array(str.length); + for (let i = 0; i < str.length; ++i) { + bytes[i] = str.charCodeAt(i); + } + return bytes; } -const DNS = exports.DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; -const URL = exports.URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; -function v35(name, version, hashfunc) { - function generateUUID(value, namespace, buf, offset) { - var _namespace; - if (typeof value === 'string') { - value = stringToBytes(value); - } +export const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; +export const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; +export default function v35(version, hash, value, namespace, buf, offset) { + const valueBytes = typeof value === 'string' ? stringToBytes(value) : value; + const namespaceBytes = typeof namespace === 'string' ? parse(namespace) : namespace; if (typeof namespace === 'string') { - namespace = (0, _parse.default)(namespace); + namespace = parse(namespace); } - if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) { - throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)'); + if (namespace?.length !== 16) { + throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)'); } - - // Compute hash of namespace and value, Per 4.3 - // Future: Use spread syntax when supported on all platforms, e.g. `bytes = - // hashfunc([...namespace, ... value])` - let bytes = new Uint8Array(16 + value.length); - bytes.set(namespace); - bytes.set(value, namespace.length); - bytes = hashfunc(bytes); - bytes[6] = bytes[6] & 0x0f | version; - bytes[8] = bytes[8] & 0x3f | 0x80; + let bytes = new Uint8Array(16 + valueBytes.length); + bytes.set(namespaceBytes); + bytes.set(valueBytes, namespaceBytes.length); + bytes = hash(bytes); + bytes[6] = (bytes[6] & 0x0f) | version; + bytes[8] = (bytes[8] & 0x3f) | 0x80; if (buf) { - offset = offset || 0; - for (let i = 0; i < 16; ++i) { - buf[offset + i] = bytes[i]; - } - return buf; + offset = offset || 0; + if (offset < 0 || offset + 16 > buf.length) { + throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`); + } + for (let i = 0; i < 16; ++i) { + buf[offset + i] = bytes[i]; + } + return buf; } - return (0, _stringify.unsafeStringify)(bytes); - } - - // Function#name is not settable on some platforms (#270) - try { - generateUUID.name = name; - } catch (err) {} - - // For CommonJS default export support - generateUUID.DNS = DNS; - generateUUID.URL = URL; - return generateUUID; -} \ No newline at end of file + return unsafeStringify(bytes); +} diff --git a/static/node_modules/uuid/dist/v4.js b/static/node_modules/uuid/dist/v4.js index 6f2744b..cc9dc2d 100644 --- a/static/node_modules/uuid/dist/v4.js +++ b/static/node_modules/uuid/dist/v4.js @@ -1,32 +1,30 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _native = _interopRequireDefault(require("./native.js")); -var _rng = _interopRequireDefault(require("./rng.js")); -var _stringify = require("./stringify.js"); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -function v4(options, buf, offset) { - if (_native.default.randomUUID && !buf && !options) { - return _native.default.randomUUID(); - } - options = options || {}; - const rnds = options.random || (options.rng || _rng.default)(); - - // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` - rnds[6] = rnds[6] & 0x0f | 0x40; - rnds[8] = rnds[8] & 0x3f | 0x80; - - // Copy bytes to buffer, if provided - if (buf) { - offset = offset || 0; - for (let i = 0; i < 16; ++i) { - buf[offset + i] = rnds[i]; +import native from './native.js'; +import rng from './rng.js'; +import { unsafeStringify } from './stringify.js'; +function _v4(options, buf, offset) { + options = options || {}; + const rnds = options.random ?? options.rng?.() ?? rng(); + if (rnds.length < 16) { + throw new Error('Random bytes length must be >= 16'); } - return buf; - } - return (0, _stringify.unsafeStringify)(rnds); + rnds[6] = (rnds[6] & 0x0f) | 0x40; + rnds[8] = (rnds[8] & 0x3f) | 0x80; + if (buf) { + offset = offset || 0; + if (offset < 0 || offset + 16 > buf.length) { + throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`); + } + for (let i = 0; i < 16; ++i) { + buf[offset + i] = rnds[i]; + } + return buf; + } + return unsafeStringify(rnds); } -var _default = exports.default = v4; \ No newline at end of file +function v4(options, buf, offset) { + if (native.randomUUID && !buf && !options) { + return native.randomUUID(); + } + return _v4(options, buf, offset); +} +export default v4; diff --git a/static/node_modules/uuid/dist/v5.js b/static/node_modules/uuid/dist/v5.js index 63063bb..bd470a4 100644 --- a/static/node_modules/uuid/dist/v5.js +++ b/static/node_modules/uuid/dist/v5.js @@ -1,11 +1,9 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _v = _interopRequireDefault(require("./v35.js")); -var _sha = _interopRequireDefault(require("./sha1.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -const v5 = (0, _v.default)('v5', 0x50, _sha.default); -var _default = exports.default = v5; \ No newline at end of file +import sha1 from './sha1.js'; +import v35, { DNS, URL } from './v35.js'; +export { DNS, URL } from './v35.js'; +function v5(value, namespace, buf, offset) { + return v35(0x50, sha1, value, namespace, buf, offset); +} +v5.DNS = DNS; +v5.URL = URL; +export default v5; diff --git a/static/node_modules/uuid/dist/v6.js b/static/node_modules/uuid/dist/v6.js index 627c6a7..bd1fc35 100644 --- a/static/node_modules/uuid/dist/v6.js +++ b/static/node_modules/uuid/dist/v6.js @@ -1,38 +1,20 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = v6; -var _stringify = require("./stringify.js"); -var _v = _interopRequireDefault(require("./v1.js")); -var _v1ToV = _interopRequireDefault(require("./v1ToV6.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -/** - * - * @param {object} options - * @param {Uint8Array=} buf - * @param {number=} offset - * @returns - */ -function v6(options = {}, buf, offset = 0) { - // v6 is v1 with different field layout, so we start with a v1 UUID, albeit - // with slightly different behavior around how the clock_seq and node fields - // are randomized, which is why we call v1 with _v6: true. - let bytes = (0, _v.default)({ - ...options, - _v6: true - }, new Uint8Array(16)); - - // Reorder the fields to v6 layout. - bytes = (0, _v1ToV.default)(bytes); - - // Return as a byte array if requested - if (buf) { - for (let i = 0; i < 16; i++) { - buf[offset + i] = bytes[i]; +import { unsafeStringify } from './stringify.js'; +import v1 from './v1.js'; +import v1ToV6 from './v1ToV6.js'; +function v6(options, buf, offset) { + options ??= {}; + offset ??= 0; + let bytes = v1({ ...options, _v6: true }, new Uint8Array(16)); + bytes = v1ToV6(bytes); + if (buf) { + if (offset < 0 || offset + 16 > buf.length) { + throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`); + } + for (let i = 0; i < 16; i++) { + buf[offset + i] = bytes[i]; + } + return buf; } - return buf; - } - return (0, _stringify.unsafeStringify)(bytes); -} \ No newline at end of file + return unsafeStringify(bytes); +} +export default v6; diff --git a/static/node_modules/uuid/dist/v6ToV1.js b/static/node_modules/uuid/dist/v6ToV1.js index a019861..bfd942f 100644 --- a/static/node_modules/uuid/dist/v6ToV1.js +++ b/static/node_modules/uuid/dist/v6ToV1.js @@ -1,26 +1,10 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = v6ToV1; -var _parse = _interopRequireDefault(require("./parse.js")); -var _stringify = require("./stringify.js"); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -/** - * Convert a v6 UUID to a v1 UUID - * - * @param {string|Uint8Array} uuid - The v6 UUID to convert to v6 - * @returns {string|Uint8Array} The v1 UUID as the same type as the `uuid` arg - * (string or Uint8Array) - */ -function v6ToV1(uuid) { - const v6Bytes = typeof uuid === 'string' ? (0, _parse.default)(uuid) : uuid; - const v1Bytes = _v6ToV1(v6Bytes); - return typeof uuid === 'string' ? (0, _stringify.unsafeStringify)(v1Bytes) : v1Bytes; +import parse from './parse.js'; +import { unsafeStringify } from './stringify.js'; +export default function v6ToV1(uuid) { + const v6Bytes = typeof uuid === 'string' ? parse(uuid) : uuid; + const v1Bytes = _v6ToV1(v6Bytes); + return typeof uuid === 'string' ? unsafeStringify(v1Bytes) : v1Bytes; } - -// Do the field transformation needed for v6 -> v1 function _v6ToV1(v6Bytes) { - return Uint8Array.of((v6Bytes[3] & 0x0f) << 4 | v6Bytes[4] >> 4 & 0x0f, (v6Bytes[4] & 0x0f) << 4 | (v6Bytes[5] & 0xf0) >> 4, (v6Bytes[5] & 0x0f) << 4 | v6Bytes[6] & 0x0f, v6Bytes[7], (v6Bytes[1] & 0x0f) << 4 | (v6Bytes[2] & 0xf0) >> 4, (v6Bytes[2] & 0x0f) << 4 | (v6Bytes[3] & 0xf0) >> 4, 0x10 | (v6Bytes[0] & 0xf0) >> 4, (v6Bytes[0] & 0x0f) << 4 | (v6Bytes[1] & 0xf0) >> 4, v6Bytes[8], v6Bytes[9], v6Bytes[10], v6Bytes[11], v6Bytes[12], v6Bytes[13], v6Bytes[14], v6Bytes[15]); -} \ No newline at end of file + return Uint8Array.of(((v6Bytes[3] & 0x0f) << 4) | ((v6Bytes[4] >> 4) & 0x0f), ((v6Bytes[4] & 0x0f) << 4) | ((v6Bytes[5] & 0xf0) >> 4), ((v6Bytes[5] & 0x0f) << 4) | (v6Bytes[6] & 0x0f), v6Bytes[7], ((v6Bytes[1] & 0x0f) << 4) | ((v6Bytes[2] & 0xf0) >> 4), ((v6Bytes[2] & 0x0f) << 4) | ((v6Bytes[3] & 0xf0) >> 4), 0x10 | ((v6Bytes[0] & 0xf0) >> 4), ((v6Bytes[0] & 0x0f) << 4) | ((v6Bytes[1] & 0xf0) >> 4), v6Bytes[8], v6Bytes[9], v6Bytes[10], v6Bytes[11], v6Bytes[12], v6Bytes[13], v6Bytes[14], v6Bytes[15]); +} diff --git a/static/node_modules/uuid/dist/v7.js b/static/node_modules/uuid/dist/v7.js index 85831e1..276c9bf 100644 --- a/static/node_modules/uuid/dist/v7.js +++ b/static/node_modules/uuid/dist/v7.js @@ -1,152 +1,65 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _rng = _interopRequireDefault(require("./rng.js")); -var _stringify = require("./stringify.js"); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } -/** - * UUID V7 - Unix Epoch time-based UUID - * - * The IETF has published RFC9562, introducing 3 new UUID versions (6,7,8). This - * implementation of V7 is based on the accepted, though not yet approved, - * revisions. - * - * RFC 9562:https://www.rfc-editor.org/rfc/rfc9562.html Universally Unique - * IDentifiers (UUIDs) - - * - * Sample V7 value: - * https://www.rfc-editor.org/rfc/rfc9562.html#name-example-of-a-uuidv7-value - * - * Monotonic Bit Layout: RFC rfc9562.6.2 Method 1, Dedicated Counter Bits ref: - * https://www.rfc-editor.org/rfc/rfc9562.html#section-6.2-5.1 - * - * 0 1 2 3 0 1 2 3 4 5 6 - * 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * | unix_ts_ms | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * | unix_ts_ms | ver | seq_hi | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * |var| seq_low | rand | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * | rand | - * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ - * - * seq is a 31 bit serialized counter; comprised of 12 bit seq_hi and 19 bit - * seq_low, and randomly initialized upon timestamp change. 31 bit counter size - * was selected as any bitwise operations in node are done as _signed_ 32 bit - * ints. we exclude the sign bit. - */ - -let _seqLow = null; -let _seqHigh = null; -let _msecs = 0; +import rng from './rng.js'; +import { unsafeStringify } from './stringify.js'; +const _state = {}; function v7(options, buf, offset) { - options = options || {}; - - // initialize buffer and pointer - let i = buf && offset || 0; - const b = buf || new Uint8Array(16); - - // rnds is Uint8Array(16) filled with random bytes - const rnds = options.random || (options.rng || _rng.default)(); - - // milliseconds since unix epoch, 1970-01-01 00:00 - const msecs = options.msecs !== undefined ? options.msecs : Date.now(); - - // seq is user provided 31 bit counter - let seq = options.seq !== undefined ? options.seq : null; - - // initialize local seq high/low parts - let seqHigh = _seqHigh; - let seqLow = _seqLow; - - // check if clock has advanced and user has not provided msecs - if (msecs > _msecs && options.msecs === undefined) { - _msecs = msecs; - - // unless user provided seq, reset seq parts - if (seq !== null) { - seqHigh = null; - seqLow = null; + let bytes; + if (options) { + bytes = v7Bytes(options.random ?? options.rng?.() ?? rng(), options.msecs, options.seq, buf, offset); } - } - - // if we have a user provided seq - if (seq !== null) { - // trim provided seq to 31 bits of value, avoiding overflow - if (seq > 0x7fffffff) { - seq = 0x7fffffff; + else { + const now = Date.now(); + const rnds = rng(); + updateV7State(_state, now, rnds); + bytes = v7Bytes(rnds, _state.msecs, _state.seq, buf, offset); } - - // split provided seq into high/low parts - seqHigh = seq >>> 19 & 0xfff; - seqLow = seq & 0x7ffff; - } - - // randomly initialize seq - if (seqHigh === null || seqLow === null) { - seqHigh = rnds[6] & 0x7f; - seqHigh = seqHigh << 8 | rnds[7]; - seqLow = rnds[8] & 0x3f; // pad for var - seqLow = seqLow << 8 | rnds[9]; - seqLow = seqLow << 5 | rnds[10] >>> 3; - } - - // increment seq if within msecs window - if (msecs + 10000 > _msecs && seq === null) { - if (++seqLow > 0x7ffff) { - seqLow = 0; - if (++seqHigh > 0xfff) { - seqHigh = 0; - - // increment internal _msecs. this allows us to continue incrementing - // while staying monotonic. Note, once we hit 10k milliseconds beyond system - // clock, we will reset breaking monotonicity (after (2^31)*10000 generations) - _msecs++; - } - } - } else { - // resetting; we have advanced more than - // 10k milliseconds beyond system clock - _msecs = msecs; - } - _seqHigh = seqHigh; - _seqLow = seqLow; - - // [bytes 0-5] 48 bits of local timestamp - b[i++] = _msecs / 0x10000000000 & 0xff; - b[i++] = _msecs / 0x100000000 & 0xff; - b[i++] = _msecs / 0x1000000 & 0xff; - b[i++] = _msecs / 0x10000 & 0xff; - b[i++] = _msecs / 0x100 & 0xff; - b[i++] = _msecs & 0xff; - - // [byte 6] - set 4 bits of version (7) with first 4 bits seq_hi - b[i++] = seqHigh >>> 4 & 0x0f | 0x70; - - // [byte 7] remaining 8 bits of seq_hi - b[i++] = seqHigh & 0xff; - - // [byte 8] - variant (2 bits), first 6 bits seq_low - b[i++] = seqLow >>> 13 & 0x3f | 0x80; - - // [byte 9] 8 bits seq_low - b[i++] = seqLow >>> 5 & 0xff; - - // [byte 10] remaining 5 bits seq_low, 3 bits random - b[i++] = seqLow << 3 & 0xff | rnds[10] & 0x07; - - // [bytes 11-15] always random - b[i++] = rnds[11]; - b[i++] = rnds[12]; - b[i++] = rnds[13]; - b[i++] = rnds[14]; - b[i++] = rnds[15]; - return buf || (0, _stringify.unsafeStringify)(b); + return buf ?? unsafeStringify(bytes); } -var _default = exports.default = v7; \ No newline at end of file +export function updateV7State(state, now, rnds) { + state.msecs ??= -Infinity; + state.seq ??= 0; + if (now > state.msecs) { + state.seq = (rnds[6] << 23) | (rnds[7] << 16) | (rnds[8] << 8) | rnds[9]; + state.msecs = now; + } + else { + state.seq = (state.seq + 1) | 0; + if (state.seq === 0) { + state.msecs++; + } + } + return state; +} +function v7Bytes(rnds, msecs, seq, buf, offset = 0) { + if (rnds.length < 16) { + throw new Error('Random bytes length must be >= 16'); + } + if (!buf) { + buf = new Uint8Array(16); + offset = 0; + } + else { + if (offset < 0 || offset + 16 > buf.length) { + throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`); + } + } + msecs ??= Date.now(); + seq ??= ((rnds[6] * 0x7f) << 24) | (rnds[7] << 16) | (rnds[8] << 8) | rnds[9]; + buf[offset++] = (msecs / 0x10000000000) & 0xff; + buf[offset++] = (msecs / 0x100000000) & 0xff; + buf[offset++] = (msecs / 0x1000000) & 0xff; + buf[offset++] = (msecs / 0x10000) & 0xff; + buf[offset++] = (msecs / 0x100) & 0xff; + buf[offset++] = msecs & 0xff; + buf[offset++] = 0x70 | ((seq >>> 28) & 0x0f); + buf[offset++] = (seq >>> 20) & 0xff; + buf[offset++] = 0x80 | ((seq >>> 14) & 0x3f); + buf[offset++] = (seq >>> 6) & 0xff; + buf[offset++] = ((seq << 2) & 0xff) | (rnds[10] & 0x03); + buf[offset++] = rnds[11]; + buf[offset++] = rnds[12]; + buf[offset++] = rnds[13]; + buf[offset++] = rnds[14]; + buf[offset++] = rnds[15]; + return buf; +} +export default v7; diff --git a/static/node_modules/uuid/dist/validate.js b/static/node_modules/uuid/dist/validate.js index d47181a..444a1a2 100644 --- a/static/node_modules/uuid/dist/validate.js +++ b/static/node_modules/uuid/dist/validate.js @@ -1,12 +1,5 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _regex = _interopRequireDefault(require("./regex.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } +import REGEX from './regex.js'; function validate(uuid) { - return typeof uuid === 'string' && _regex.default.test(uuid); + return typeof uuid === 'string' && REGEX.test(uuid); } -var _default = exports.default = validate; \ No newline at end of file +export default validate; diff --git a/static/node_modules/uuid/dist/version.js b/static/node_modules/uuid/dist/version.js index 0c6bbdd..bae91d3 100644 --- a/static/node_modules/uuid/dist/version.js +++ b/static/node_modules/uuid/dist/version.js @@ -1,15 +1,8 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _validate = _interopRequireDefault(require("./validate.js")); -function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } +import validate from './validate.js'; function version(uuid) { - if (!(0, _validate.default)(uuid)) { - throw TypeError('Invalid UUID'); - } - return parseInt(uuid.slice(14, 15), 16); + if (!validate(uuid)) { + throw TypeError('Invalid UUID'); + } + return parseInt(uuid.slice(14, 15), 16); } -var _default = exports.default = version; \ No newline at end of file +export default version; diff --git a/static/node_modules/uuid/package.json b/static/node_modules/uuid/package.json index dea12c6..2026b59 100644 --- a/static/node_modules/uuid/package.json +++ b/static/node_modules/uuid/package.json @@ -1,7 +1,8 @@ { "name": "uuid", - "version": "10.0.0", + "version": "13.0.2", "description": "RFC9562 UUIDs", + "type": "module", "funding": [ "https://github.com/sponsors/broofa", "https://github.com/sponsors/ctavan" @@ -19,111 +20,87 @@ ], "license": "MIT", "bin": { - "uuid": "dist/bin/uuid" + "uuid": "./dist-node/bin/uuid" }, "sideEffects": false, - "main": "./dist/index.js", + "types": "./dist/index.d.ts", "exports": { ".": { - "node": { - "module": "./dist/esm-node/index.js", - "require": "./dist/index.js", - "import": "./wrapper.mjs" - }, - "browser": { - "import": "./dist/esm-browser/index.js", - "require": "./dist/commonjs-browser/index.js" - }, - "default": "./dist/esm-browser/index.js" + "node": "./dist-node/index.js", + "default": "./dist/index.js" }, "./package.json": "./package.json" }, - "module": "./dist/esm-node/index.js", - "browser": { - "./dist/esm-node/index.js": "./dist/esm-browser/index.js", - "./dist/md5.js": "./dist/md5-browser.js", - "./dist/native.js": "./dist/native-browser.js", - "./dist/rng.js": "./dist/rng-browser.js", - "./dist/sha1.js": "./dist/sha1-browser.js" - }, "files": [ - "CHANGELOG.md", - "CONTRIBUTING.md", - "LICENSE.md", - "README.md", "dist", - "wrapper.mjs" + "dist-node", + "!**/test" ], "devDependencies": { - "@babel/cli": "7.24.6", - "@babel/core": "7.24.6", - "@babel/eslint-parser": "7.24.6", - "@babel/plugin-syntax-import-attributes": "7.24.6", - "@babel/preset-env": "7.24.6", - "@commitlint/cli": "19.3.0", - "@commitlint/config-conventional": "19.2.2", - "@wdio/browserstack-service": "7.16.10", - "@wdio/cli": "7.16.10", - "@wdio/jasmine-framework": "7.16.6", - "@wdio/local-runner": "7.16.10", - "@wdio/spec-reporter": "7.16.9", - "@wdio/static-server-service": "7.16.6", - "bundlewatch": "0.3.3", - "eslint": "9.4.0", - "eslint-plugin-prettier": "5.1.3", - "globals": "15.3.0", - "husky": "9.0.11", + "@babel/eslint-parser": "7.27.1", + "@commitlint/cli": "19.8.0", + "@commitlint/config-conventional": "19.8.0", + "@eslint/js": "9.26.0", + "bundlewatch": "0.4.1", + "commander": "13.1.0", + "eslint": "9.26.0", + "eslint-config-prettier": "10.1.2", + "eslint-plugin-prettier": "5.4.0", + "globals": "16.0.0", + "husky": "9.1.7", "jest": "29.7.0", - "lint-staged": "15.2.5", - "neostandard": "0.5.1", + "lint-staged": "15.5.2", + "neostandard": "0.12.1", "npm-run-all": "4.1.5", - "optional-dev-dependency": "2.0.1", - "prettier": "3.3.0", - "random-seed": "0.3.0", - "runmd": "1.3.9", - "standard-version": "9.5.0" + "prettier": "3.5.3", + "release-please": "17.0.0", + "runmd": "1.4.1", + "standard-version": "9.5.0", + "typescript": "5.2.2", + "typescript-eslint": "8.32.0" }, "optionalDevDependencies": { - "@wdio/browserstack-service": "7.16.10", - "@wdio/cli": "7.16.10", - "@wdio/jasmine-framework": "7.16.6", - "@wdio/local-runner": "7.16.10", - "@wdio/spec-reporter": "7.16.9", - "@wdio/static-server-service": "7.16.6" + "@wdio/browserstack-service": "9.2.1", + "@wdio/cli": "9.2.1", + "@wdio/jasmine-framework": "9.2.1", + "@wdio/local-runner": "9.2.1", + "@wdio/spec-reporter": "9.1.3", + "@wdio/static-server-service": "9.1.3" }, "scripts": { - "examples:browser:webpack:build": "cd examples/browser-webpack && npm install && npm run build", - "examples:browser:rollup:build": "cd examples/browser-rollup && npm install && npm run build", - "examples:node:commonjs:test": "cd examples/node-commonjs && npm install && npm test", - "examples:node:esmodules:test": "cd examples/node-esmodules && npm install && npm test", - "examples:node:jest:test": "cd examples/node-jest && npm install && npm test", - "prepare": "husky install", + "build": "./scripts/build.sh", + "build:watch": "tsc --watch -p tsconfig.json", + "bundlewatch": "npm run pretest:browser && bundlewatch --config bundlewatch.config.json", + "docs:diff": "npm run docs && git diff --quiet -I \"[0-9a-f-]{36}\" README.md", + "docs": "npm run build && npx runmd --output=README.md README_js.md", + "eslint:check": "eslint src/ test/ examples/ *.[jt]s", + "eslint:fix": "eslint --fix src/ test/ examples/ *.[jt]s", + "examples:browser:rollup:build": "cd examples/browser-rollup && npm run build", + "examples:browser:webpack:build": "cd examples/browser-webpack && npm run build", + "examples:node:esmodules:test": "cd examples/node-esmodules && npm test", + "examples:node:jest:test": "cd examples/node-jest && npm test", + "examples:node:typescript:test": "cd examples/typescript && npm test", "lint": "npm run eslint:check && npm run prettier:check", - "eslint:check": "eslint src/ test/ examples/ *.js", - "eslint:fix": "eslint --fix src/ test/ examples/ *.js", - "pretest": "npm run build", - "test": "BABEL_ENV=commonjsNode node --throw-deprecation node_modules/.bin/jest test/unit/", - "test:matching": "BABEL_ENV=commonjsNode node --throw-deprecation node_modules/.bin/jest test/unit/ -t", - "pretest:browser": "optional-dev-dependency && npm run build && npm-run-all --parallel examples:browser:**", - "test:browser": "wdio run ./wdio.conf.js", - "pretest:node": "npm run build", - "test:node": "npm-run-all --parallel examples:node:**", - "test:pack": "./scripts/testpack.sh", + "md": "runmd --watch --output=README.md README_js.md", + "prepack": "npm run build -- --no-pack", + "prepare": "husky", + "prepublishOnly": "npm run build", "pretest:benchmark": "npm run build", - "test:benchmark": "cd examples/benchmark && HUSKY=0 npm install && npm test", + "pretest:browser": "./scripts/iodd && npm run build && npm-run-all --parallel examples:browser:**", + "pretest:node": "npm run build", + "pretest": "npm run build", "prettier:check": "prettier --check .", "prettier:fix": "prettier --write .", - "bundlewatch": "npm run pretest:browser && bundlewatch --config bundlewatch.config.json", - "md": "runmd --watch --output=README.md README_js.md", - "docs": "npm run build && npx runmd --output=README.md README_js.md", - "docs:diff": "npm run docs && git diff --quiet README.md", - "build": "./scripts/build.sh", - "prepack": "npm run build", - "release": "standard-version --no-verify" + "release": "standard-version --no-verify", + "test:benchmark": "cd examples/benchmark && npm test", + "test:browser": "wdio run ./wdio.conf.js", + "test:node": "npm-run-all --parallel examples:node:**", + "test:watch": "node --test --enable-source-maps --watch dist-node/test/*.js", + "test": "node --test --enable-source-maps dist-node/test/*.js" }, "repository": { "type": "git", - "url": "git+https://github.com/uuidjs/uuid.git" + "url": "https://github.com/uuidjs/uuid.git" }, "lint-staged": { "*": [ @@ -138,5 +115,5 @@ "postchangelog": "prettier --write CHANGELOG.md" } }, - "packageManager": "npm@10.8.1+sha256.b8807aebb9656758e2872fa6e7c564b506aa2faa9297439a478d471d2fe32483" + "packageManager": "npm@11.3.0" } diff --git a/static/node_modules/uuid/wrapper.mjs b/static/node_modules/uuid/wrapper.mjs deleted file mode 100644 index fba64f6..0000000 --- a/static/node_modules/uuid/wrapper.mjs +++ /dev/null @@ -1,15 +0,0 @@ -import uuid from './dist/index.js'; -export const v1 = uuid.v1; -export const v1ToV6 = uuid.v1ToV6; -export const v3 = uuid.v3; -export const v4 = uuid.v4; -export const v5 = uuid.v5; -export const v6 = uuid.v6; -export const v6ToV1 = uuid.v6ToV1; -export const v7 = uuid.v7; -export const NIL = uuid.NIL; -export const MAX = uuid.MAX; -export const version = uuid.version; -export const validate = uuid.validate; -export const stringify = uuid.stringify; -export const parse = uuid.parse; diff --git a/static/package-lock.json b/static/package-lock.json index a717fbc..8b5751a 100644 --- a/static/package-lock.json +++ b/static/package-lock.json @@ -5,17 +5,19 @@ "packages": { "": { "dependencies": { - "bloatless-react": "^1.1.3", - "esbuild": "latest" + "bloatless-react": "^1.4.0", + "esbuild": "latest", + "udn-frontend": "^1.0.6" } }, "node_modules/@esbuild/aix-ppc64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.23.0.tgz", - "integrity": "sha512-3sG8Zwa5fMcA9bgqB8AfWPQ+HFke6uD3h1s3RIwUNK8EG7a4buxvuFTs3j1IMs2NXAk9F30C/FF4vxRgQCcmoQ==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz", + "integrity": "sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==", "cpu": [ "ppc64" ], + "license": "MIT", "optional": true, "os": [ "aix" @@ -25,12 +27,13 @@ } }, "node_modules/@esbuild/android-arm": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.23.0.tgz", - "integrity": "sha512-+KuOHTKKyIKgEEqKbGTK8W7mPp+hKinbMBeEnNzjJGyFcWsfrXjSTNluJHCY1RqhxFurdD8uNXQDei7qDlR6+g==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.2.tgz", + "integrity": "sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==", "cpu": [ "arm" ], + "license": "MIT", "optional": true, "os": [ "android" @@ -40,12 +43,13 @@ } }, "node_modules/@esbuild/android-arm64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.23.0.tgz", - "integrity": "sha512-EuHFUYkAVfU4qBdyivULuu03FhJO4IJN9PGuABGrFy4vUuzk91P2d+npxHcFdpUnfYKy0PuV+n6bKIpHOB3prQ==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.2.tgz", + "integrity": "sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==", "cpu": [ "arm64" ], + "license": "MIT", "optional": true, "os": [ "android" @@ -55,12 +59,13 @@ } }, "node_modules/@esbuild/android-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.23.0.tgz", - "integrity": "sha512-WRrmKidLoKDl56LsbBMhzTTBxrsVwTKdNbKDalbEZr0tcsBgCLbEtoNthOW6PX942YiYq8HzEnb4yWQMLQuipQ==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.2.tgz", + "integrity": "sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==", "cpu": [ "x64" ], + "license": "MIT", "optional": true, "os": [ "android" @@ -70,12 +75,13 @@ } }, "node_modules/@esbuild/darwin-arm64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.23.0.tgz", - "integrity": "sha512-YLntie/IdS31H54Ogdn+v50NuoWF5BDkEUFpiOChVa9UnKpftgwzZRrI4J132ETIi+D8n6xh9IviFV3eXdxfow==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.2.tgz", + "integrity": "sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==", "cpu": [ "arm64" ], + "license": "MIT", "optional": true, "os": [ "darwin" @@ -85,12 +91,13 @@ } }, "node_modules/@esbuild/darwin-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.23.0.tgz", - "integrity": "sha512-IMQ6eme4AfznElesHUPDZ+teuGwoRmVuuixu7sv92ZkdQcPbsNHzutd+rAfaBKo8YK3IrBEi9SLLKWJdEvJniQ==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.2.tgz", + "integrity": "sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==", "cpu": [ "x64" ], + "license": "MIT", "optional": true, "os": [ "darwin" @@ -100,12 +107,13 @@ } }, "node_modules/@esbuild/freebsd-arm64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.23.0.tgz", - "integrity": "sha512-0muYWCng5vqaxobq6LB3YNtevDFSAZGlgtLoAc81PjUfiFz36n4KMpwhtAd4he8ToSI3TGyuhyx5xmiWNYZFyw==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.2.tgz", + "integrity": "sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==", "cpu": [ "arm64" ], + "license": "MIT", "optional": true, "os": [ "freebsd" @@ -115,12 +123,13 @@ } }, "node_modules/@esbuild/freebsd-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.23.0.tgz", - "integrity": "sha512-XKDVu8IsD0/q3foBzsXGt/KjD/yTKBCIwOHE1XwiXmrRwrX6Hbnd5Eqn/WvDekddK21tfszBSrE/WMaZh+1buQ==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.2.tgz", + "integrity": "sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==", "cpu": [ "x64" ], + "license": "MIT", "optional": true, "os": [ "freebsd" @@ -130,12 +139,13 @@ } }, "node_modules/@esbuild/linux-arm": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.23.0.tgz", - "integrity": "sha512-SEELSTEtOFu5LPykzA395Mc+54RMg1EUgXP+iw2SJ72+ooMwVsgfuwXo5Fn0wXNgWZsTVHwY2cg4Vi/bOD88qw==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.2.tgz", + "integrity": "sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==", "cpu": [ "arm" ], + "license": "MIT", "optional": true, "os": [ "linux" @@ -145,12 +155,13 @@ } }, "node_modules/@esbuild/linux-arm64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.23.0.tgz", - "integrity": "sha512-j1t5iG8jE7BhonbsEg5d9qOYcVZv/Rv6tghaXM/Ug9xahM0nX/H2gfu6X6z11QRTMT6+aywOMA8TDkhPo8aCGw==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz", + "integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==", "cpu": [ "arm64" ], + "license": "MIT", "optional": true, "os": [ "linux" @@ -160,12 +171,13 @@ } }, "node_modules/@esbuild/linux-ia32": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.23.0.tgz", - "integrity": "sha512-P7O5Tkh2NbgIm2R6x1zGJJsnacDzTFcRWZyTTMgFdVit6E98LTxO+v8LCCLWRvPrjdzXHx9FEOA8oAZPyApWUA==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.2.tgz", + "integrity": "sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==", "cpu": [ "ia32" ], + "license": "MIT", "optional": true, "os": [ "linux" @@ -175,12 +187,13 @@ } }, "node_modules/@esbuild/linux-loong64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.23.0.tgz", - "integrity": "sha512-InQwepswq6urikQiIC/kkx412fqUZudBO4SYKu0N+tGhXRWUqAx+Q+341tFV6QdBifpjYgUndV1hhMq3WeJi7A==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.2.tgz", + "integrity": "sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==", "cpu": [ "loong64" ], + "license": "MIT", "optional": true, "os": [ "linux" @@ -190,12 +203,13 @@ } }, "node_modules/@esbuild/linux-mips64el": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.23.0.tgz", - "integrity": "sha512-J9rflLtqdYrxHv2FqXE2i1ELgNjT+JFURt/uDMoPQLcjWQA5wDKgQA4t/dTqGa88ZVECKaD0TctwsUfHbVoi4w==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.2.tgz", + "integrity": "sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==", "cpu": [ "mips64el" ], + "license": "MIT", "optional": true, "os": [ "linux" @@ -205,12 +219,13 @@ } }, "node_modules/@esbuild/linux-ppc64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.23.0.tgz", - "integrity": "sha512-cShCXtEOVc5GxU0fM+dsFD10qZ5UpcQ8AM22bYj0u/yaAykWnqXJDpd77ublcX6vdDsWLuweeuSNZk4yUxZwtw==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.2.tgz", + "integrity": "sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==", "cpu": [ "ppc64" ], + "license": "MIT", "optional": true, "os": [ "linux" @@ -220,12 +235,13 @@ } }, "node_modules/@esbuild/linux-riscv64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.23.0.tgz", - "integrity": "sha512-HEtaN7Y5UB4tZPeQmgz/UhzoEyYftbMXrBCUjINGjh3uil+rB/QzzpMshz3cNUxqXN7Vr93zzVtpIDL99t9aRw==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.2.tgz", + "integrity": "sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==", "cpu": [ "riscv64" ], + "license": "MIT", "optional": true, "os": [ "linux" @@ -235,12 +251,13 @@ } }, "node_modules/@esbuild/linux-s390x": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.23.0.tgz", - "integrity": "sha512-WDi3+NVAuyjg/Wxi+o5KPqRbZY0QhI9TjrEEm+8dmpY9Xir8+HE/HNx2JoLckhKbFopW0RdO2D72w8trZOV+Wg==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.2.tgz", + "integrity": "sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==", "cpu": [ "s390x" ], + "license": "MIT", "optional": true, "os": [ "linux" @@ -250,12 +267,13 @@ } }, "node_modules/@esbuild/linux-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.23.0.tgz", - "integrity": "sha512-a3pMQhUEJkITgAw6e0bWA+F+vFtCciMjW/LPtoj99MhVt+Mfb6bbL9hu2wmTZgNd994qTAEw+U/r6k3qHWWaOQ==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.2.tgz", + "integrity": "sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==", "cpu": [ "x64" ], + "license": "MIT", "optional": true, "os": [ "linux" @@ -264,13 +282,30 @@ "node": ">=18" } }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.2.tgz", + "integrity": "sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, "node_modules/@esbuild/netbsd-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.23.0.tgz", - "integrity": "sha512-cRK+YDem7lFTs2Q5nEv/HHc4LnrfBCbH5+JHu6wm2eP+d8OZNoSMYgPZJq78vqQ9g+9+nMuIsAO7skzphRXHyw==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.2.tgz", + "integrity": "sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==", "cpu": [ "x64" ], + "license": "MIT", "optional": true, "os": [ "netbsd" @@ -280,12 +315,13 @@ } }, "node_modules/@esbuild/openbsd-arm64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.23.0.tgz", - "integrity": "sha512-suXjq53gERueVWu0OKxzWqk7NxiUWSUlrxoZK7usiF50C6ipColGR5qie2496iKGYNLhDZkPxBI3erbnYkU0rQ==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.2.tgz", + "integrity": "sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==", "cpu": [ "arm64" ], + "license": "MIT", "optional": true, "os": [ "openbsd" @@ -295,12 +331,13 @@ } }, "node_modules/@esbuild/openbsd-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.23.0.tgz", - "integrity": "sha512-6p3nHpby0DM/v15IFKMjAaayFhqnXV52aEmv1whZHX56pdkK+MEaLoQWj+H42ssFarP1PcomVhbsR4pkz09qBg==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.2.tgz", + "integrity": "sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==", "cpu": [ "x64" ], + "license": "MIT", "optional": true, "os": [ "openbsd" @@ -309,13 +346,30 @@ "node": ">=18" } }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.2.tgz", + "integrity": "sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, "node_modules/@esbuild/sunos-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.23.0.tgz", - "integrity": "sha512-BFelBGfrBwk6LVrmFzCq1u1dZbG4zy/Kp93w2+y83Q5UGYF1d8sCzeLI9NXjKyujjBBniQa8R8PzLFAUrSM9OA==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.2.tgz", + "integrity": "sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==", "cpu": [ "x64" ], + "license": "MIT", "optional": true, "os": [ "sunos" @@ -325,12 +379,13 @@ } }, "node_modules/@esbuild/win32-arm64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.23.0.tgz", - "integrity": "sha512-lY6AC8p4Cnb7xYHuIxQ6iYPe6MfO2CC43XXKo9nBXDb35krYt7KGhQnOkRGar5psxYkircpCqfbNDB4uJbS2jQ==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.2.tgz", + "integrity": "sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==", "cpu": [ "arm64" ], + "license": "MIT", "optional": true, "os": [ "win32" @@ -340,12 +395,13 @@ } }, "node_modules/@esbuild/win32-ia32": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.23.0.tgz", - "integrity": "sha512-7L1bHlOTcO4ByvI7OXVI5pNN6HSu6pUQq9yodga8izeuB1KcT2UkHaH6118QJwopExPn0rMHIseCTx1CRo/uNA==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.2.tgz", + "integrity": "sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==", "cpu": [ "ia32" ], + "license": "MIT", "optional": true, "os": [ "win32" @@ -355,12 +411,13 @@ } }, "node_modules/@esbuild/win32-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.23.0.tgz", - "integrity": "sha512-Arm+WgUFLUATuoxCJcahGuk6Yj9Pzxd6l11Zb/2aAuv5kWWvvfhLFo2fni4uSK5vzlUdCGZ/BdV5tH8klj8p8g==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.2.tgz", + "integrity": "sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==", "cpu": [ "x64" ], + "license": "MIT", "optional": true, "os": [ "win32" @@ -370,18 +427,20 @@ } }, "node_modules/bloatless-react": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/bloatless-react/-/bloatless-react-1.1.3.tgz", - "integrity": "sha512-fSJ8XLqn4K0sLR4yMOLJL+re0s/LjynGPJbZsXxBWMM6dpP2lF6lE94xppLfCdJkW4eBPJKCdqQJXWFgzsN8TA==", + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/bloatless-react/-/bloatless-react-1.4.0.tgz", + "integrity": "sha512-jtrhf8MJQ0AkN4/nnXSlhRjaWZZZawJfkxA8PX3NKe5TKhILsNhHKeYfkJpCytNG9YtfrDiYtiXUNQHqpp+oBQ==", + "license": "SEE LICENSE IN LICENSE", "dependencies": { - "uuid": "^10.0.0" + "uuid": "^13.0.0" } }, "node_modules/esbuild": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.23.0.tgz", - "integrity": "sha512-1lvV17H2bMYda/WaFb2jLPeHU3zml2k4/yagNMG8Q/YtfMjCwEUZa2eXXMgZTVSL5q1n4H7sQ0X6CdJDqqeCFA==", + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz", + "integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==", "hasInstallScript": true, + "license": "MIT", "bin": { "esbuild": "bin/esbuild" }, @@ -389,42 +448,51 @@ "node": ">=18" }, "optionalDependencies": { - "@esbuild/aix-ppc64": "0.23.0", - "@esbuild/android-arm": "0.23.0", - "@esbuild/android-arm64": "0.23.0", - "@esbuild/android-x64": "0.23.0", - "@esbuild/darwin-arm64": "0.23.0", - "@esbuild/darwin-x64": "0.23.0", - "@esbuild/freebsd-arm64": "0.23.0", - "@esbuild/freebsd-x64": "0.23.0", - "@esbuild/linux-arm": "0.23.0", - "@esbuild/linux-arm64": "0.23.0", - "@esbuild/linux-ia32": "0.23.0", - "@esbuild/linux-loong64": "0.23.0", - "@esbuild/linux-mips64el": "0.23.0", - "@esbuild/linux-ppc64": "0.23.0", - "@esbuild/linux-riscv64": "0.23.0", - "@esbuild/linux-s390x": "0.23.0", - "@esbuild/linux-x64": "0.23.0", - "@esbuild/netbsd-x64": "0.23.0", - "@esbuild/openbsd-arm64": "0.23.0", - "@esbuild/openbsd-x64": "0.23.0", - "@esbuild/sunos-x64": "0.23.0", - "@esbuild/win32-arm64": "0.23.0", - "@esbuild/win32-ia32": "0.23.0", - "@esbuild/win32-x64": "0.23.0" + "@esbuild/aix-ppc64": "0.28.2", + "@esbuild/android-arm": "0.28.2", + "@esbuild/android-arm64": "0.28.2", + "@esbuild/android-x64": "0.28.2", + "@esbuild/darwin-arm64": "0.28.2", + "@esbuild/darwin-x64": "0.28.2", + "@esbuild/freebsd-arm64": "0.28.2", + "@esbuild/freebsd-x64": "0.28.2", + "@esbuild/linux-arm": "0.28.2", + "@esbuild/linux-arm64": "0.28.2", + "@esbuild/linux-ia32": "0.28.2", + "@esbuild/linux-loong64": "0.28.2", + "@esbuild/linux-mips64el": "0.28.2", + "@esbuild/linux-ppc64": "0.28.2", + "@esbuild/linux-riscv64": "0.28.2", + "@esbuild/linux-s390x": "0.28.2", + "@esbuild/linux-x64": "0.28.2", + "@esbuild/netbsd-arm64": "0.28.2", + "@esbuild/netbsd-x64": "0.28.2", + "@esbuild/openbsd-arm64": "0.28.2", + "@esbuild/openbsd-x64": "0.28.2", + "@esbuild/openharmony-arm64": "0.28.2", + "@esbuild/sunos-x64": "0.28.2", + "@esbuild/win32-arm64": "0.28.2", + "@esbuild/win32-ia32": "0.28.2", + "@esbuild/win32-x64": "0.28.2" } }, + "node_modules/udn-frontend": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/udn-frontend/-/udn-frontend-1.0.9.tgz", + "integrity": "sha512-6wDnGEFQ0Jan33+3yxIEq2ukeuuZjtmvQylHpAL/VDa2ioCEkzTPMvskGdClXBpEh0scPUQwU5QWL6q33U4rsA==", + "license": "SEE LICENSE IN LICENSE" + }, "node_modules/uuid": { - "version": "10.0.0", - "resolved": "https://registry.npmjs.org/uuid/-/uuid-10.0.0.tgz", - "integrity": "sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==", + "version": "13.0.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-13.0.2.tgz", + "integrity": "sha512-vzi9uRZ926x4XV73S/4qQaTwPXM2JBj6/6lI/byHH1jOpCzb0zDbfytgA9LcN/hzb2l7WQSQnxITOVx5un/wGw==", "funding": [ "https://github.com/sponsors/broofa", "https://github.com/sponsors/ctavan" ], + "license": "MIT", "bin": { - "uuid": "dist/bin/uuid" + "uuid": "dist-node/bin/uuid" } } } diff --git a/static/package.json b/static/package.json index ff4daef..6b6f4f2 100644 --- a/static/package.json +++ b/static/package.json @@ -1,6 +1,6 @@ { "dependencies": { - "bloatless-react": "^1.2.6", + "bloatless-react": "^1.4.0", "esbuild": "latest", "udn-frontend": "^1.0.6" }, diff --git a/static/src/.index.tsx.swp b/static/src/.index.tsx.swp new file mode 100644 index 0000000..583a464 Binary files /dev/null and b/static/src/.index.tsx.swp differ diff --git a/static/src/.translations.tsx.swp b/static/src/.translations.tsx.swp new file mode 100644 index 0000000..b382634 Binary files /dev/null and b/static/src/.translations.tsx.swp differ diff --git a/static/src/index.tsx b/static/src/index.tsx index 384ff20..5da4478 100644 --- a/static/src/index.tsx +++ b/static/src/index.tsx @@ -2,9 +2,9 @@ import * as React from "bloatless-react"; import { InfoScreen } from "./infoScreen"; import { MainScreen } from "./mainScreen"; -import { MessageScreen } from "./messageScreen"; import { isDisconnected } from "./model"; import { translations } from "./translations"; +import {PrivacyScreen} from "./privacyScreen"; document.body.prepend( @@ -16,16 +16,20 @@ document.body.prepend( settings {translations.settings} - - chat - {translations.messages} + + privacy_tip + {translations.privacyPolicy} + + + attribution + {translations.imprint} , ); document .querySelector("main")! - .append(InfoScreen(), MainScreen(), MessageScreen()); + .append(InfoScreen(), MainScreen(), PrivacyScreen()); document.body.append(
diff --git a/static/src/messageScreen.tsx b/static/src/messageScreen.tsx deleted file mode 100644 index a835efa..0000000 --- a/static/src/messageScreen.tsx +++ /dev/null @@ -1,51 +0,0 @@ -import * as React from "bloatless-react"; - -import { - Message, - isMessageEmpty, - messages, - newMessageBody, - sendMessage, -} from "./model"; - -import { translations } from "./translations"; - -const convertMessageToElement: React.ListItemConverter = (message) => { - return ( -
-
- {message.channel} - {message.body} -
-
- ); -}; - -export function MessageScreen() { - return ( -
-
{translations.messagesReceived}
-
-
-
-
- - -
-
- ); -} diff --git a/static/src/privacyScreen.tsx b/static/src/privacyScreen.tsx new file mode 100644 index 0000000..c81a447 --- /dev/null +++ b/static/src/privacyScreen.tsx @@ -0,0 +1,28 @@ +import * as React from "bloatless-react"; + +import { translations } from "./translations"; + +const specificPolicy = new React.ListState([]); +fetch("/privacy").then(async response => { + (await response.text()) + .split("\n") + .forEach(x=>specificPolicy.add(x)) +}); + +function paragraph(x: string) { + return

{x}

+} + +export function PrivacyScreen() { + return ( +
+
+ {translations.privacyPolicy} +
+
+ {...translations.privacyPolicyContent.map(paragraph)} +
+
+
+ ); +} diff --git a/static/src/translations.tsx b/static/src/translations.tsx index 7a8c2c1..2879bb9 100644 --- a/static/src/translations.tsx +++ b/static/src/translations.tsx @@ -1,5 +1,5 @@ // STATIC -const staticTextEnglish = { +export const translations = { mailbox: "Mailbox", requestMailbox: "Request", deleteMailbox: "Delete", @@ -10,71 +10,20 @@ const staticTextEnglish = { reconnecting: "Reconnecting...", info: "Info", message: "Message", - messages: "Messages", message_placeholder: "Hello, world!", - message_placeholder_generic: "Type a message...", noMessagesReceived: "No messages received", messageLastReceived: "Last received message", - messagesReceived: "Received Messages", - send: "Send", serverInfo: "Server Info", settings: "Settings", subscribeToChannel: "Subscribe to channel", subscribe: "Subscribe", unsubscribe: "Unubscribe", + privacyPolicy: "Privacy Policy", + privacyPolicyContent: [ + "Data retention: This server may store messages sent for up to seven days if the recipient has mailboxes enabled in order to receive messages sent to them while they are offline. Mailboxes are deleted after seven days of inactivity, or upon user request. Messages are removed from mailboxes once received. Data stored about messages consists of the channel which the message is sent on, and the message body (content).", + "Processing: This server does not implement any kind of authentication or other means to identify, track, or verify user identity. The administration of this server has no means to track user activity or access data in any way not accessible to other non-administrative users. However, IP addresses are processed in order to uphold connections between client devices and this server (Legal basis: Art. 6(1)(b) GDPR – provision of the requested communication service)", + "Security: Data sent to this server is broadcasted on channels. Anyone may receive any message if they know the corresponding channel. It is strongly recommended to encrypt messages before sending them to this server (end-to-end encryption).", + "Rights: Pursuant to Art. 11 GDPR, because the administration does not retain records identifying the authors of individual transmissions, individual rights of access or erasure regarding specific messages cannot be fulfilled. Users have the right to lodge a complaint with a competent data protection authority (Art. 77 GDPR)."], + imprint: "Imprint", }; -const allTranslations: { [key: string]: typeof staticTextEnglish } = { - en: staticTextEnglish, - es: { - mailbox: "Buzón", - requestMailbox: "Solicitar", - deleteMailbox: "Eliminar", - mailboxConnected: "Buzón activado", - channel: "Canal", - channel_placeholder: "mi-canal", - disconnected: "Sin coneción", - reconnecting: "Conectando...", - info: "Info", - message: "Mensaje", - messages: "Mensajes", - message_placeholder: "Hola!", - message_placeholder_generic: "Nuevo mensaje", - noMessagesReceived: "Sin mensajes", - messageLastReceived: "Último mensaje", - messagesReceived: "Todos los Mensajes", - send: "Enviar", - serverInfo: "Información", - settings: "Configuración", - subscribeToChannel: "Suscribirse a un canal", - subscribe: "Suscribirse", - unsubscribe: "Cancelar", - }, - de: { - mailbox: "Briefkasten", - requestMailbox: "Beantragen", - deleteMailbox: "Löschen", - mailboxConnected: "Briefkasten aktiv", - channel: "Kanal", - channel_placeholder: "mein-kanal", - disconnected: "Verbindung getrennt", - reconnecting: "Verbindung wird hergestellt...", - info: "Daten", - message: "Nachricht", - messages: "Nachrichten", - message_placeholder: "Hallo!", - message_placeholder_generic: "Neue Nachricht", - noMessagesReceived: "Keine Nachrichten", - messageLastReceived: "Letzte Nachricht", - messagesReceived: "Empfangene Nachrichten", - send: "Senden", - serverInfo: "Serverdaten", - settings: "Einstellungen", - subscribeToChannel: "Kanal beitreten", - subscribe: "Beitreten", - unsubscribe: "Verlassen", - }, -}; - -const language = navigator.language.substring(0, 2); -export const translations = allTranslations[language]; diff --git a/utility.ts b/utility.ts index 5976688..8b1a8b3 100644 --- a/utility.ts +++ b/utility.ts @@ -1,7 +1,6 @@ import { PACKAGE_FILE, STATIC_DIR, WS } from "."; import Colors from "colors"; -import Fs from "fs/promises"; import Path from "path"; import { WebSocketMessage } from "./websocket-handler"; @@ -30,11 +29,6 @@ export function createFileResponse(requestPath: string): Response { return new Response(Bun.file(fullPath)); } -// OUTPUT -async function writeToLogFile(message: string): Promise { - await Fs.appendFile("logs", `${message}\n`); -} - // stats export function writeStat(label: string, value: string | number): void { console.log( @@ -49,12 +43,10 @@ export function writeSeparator(): void { // logging export function writeError(message: any): void { console.log(Colors.bold.red(message)); - writeToLogFile(message); } export function writeSuccess(message: string): void { console.log(Colors.bold.green(message)); - writeToLogFile(message); } // MESSAGES