So by applying the key prop on the fragment, our code now looks like this:
```js import React from "react";
// ... const App = () => ( <>
{name}
{title}
</React.Fragment> ))} <br /> );export default App; ```
css
html, body {
height: 100%;
margin: 0;
}
.wrapper {
height: 100%;
display: flex;
flex-direction: column;
}
.header, .footer {
background: silver;
}
.content {
flex: 1;
overflow: auto;
background: pink;
}
```html
<div class="wrapper"> <div class="header">Header</div> <div class="content"> <div style="height:1000px;">Content</div> </div> <div class="footer">Footer</div> </div>```
If the media resource is embedded (for example in a iframe), Media Session API information must be set from the embedded context. See snippet below.
```html
<iframe id="iframe"> <video>...</video> </iframe> <script> iframe.contentWindow.navigator.mediaSession.metadata = new MediaMetadata({ title: 'Never Gonna Give You Up', ... }); </script>```
Evaluation of the Music Ontology framework
```js import {Helmet} from "react-helmet";
const Demo = props => ( <br /> <div className="application"> <Helmet> <script src="/path/to/resource.js" type="text/javascript" /> </Helmet> ... </div>
); ```
```js componentDidMount () { const script = document.createElement("script"); script.src = "/path/to/resource.js"; script.async = true; document.body.appendChild(script); }
export const appendScript = (scriptToAppend) => { const script = document.createElement("script"); script.src = scriptToAppend; script.async = true; document.body.appendChild(script); }
class Demo extends React.Component { componentDidMount () { appendScript("/path/to/resource.js"); } } ```
js
useEffect(() => {
const script = document.createElement('script');
script.src = "/path/to/resource.js";
script.async = true;
document.body.appendChild(script);
return () => {
document.body.removeChild(script);
}
}, []);
```js import { useEffect } from 'react'; const importScript = resourceUrl=> { useEffect(() => { const script = document.createElement('script'); script.src = resourceUrl; script.async = true; document.body.appendChild(script); return () => { document.body.removeChild(script); } }, [resourceUrl]); };
const Demo = props => { importScript("/path/to/resource.js"); } ```
```sql FROM ZITGIST.MO.url as artist_url FROM ZITGIST.MO.artist as artist_artist FROM ZITGIST.MO.track as artist_track FROM ZITGIST.MO.album as artist_album
FROM ZITGIST.MO.album as artist_album_creatorOf where (^{artist_album_creatorOf.}^.artist = ^{artist.}^.id) FROM ZITGIST.MO.track as artist_track_creatorOf where (^{artist_track_creatorOf.}^.artist = ^{artist.}^.id)
FROM ZITGIST.MO.artistalias as artistalias text literal name where (^{artist.}^.id = ^{artistalias.}^."ref") FROM ZITGIST.MO.l_artist_url as l_artist_url where (^{artist.}^.id = ^{l_artist_url.}^.link0) where (^{artist_url.}^.id = ^{l_artist_url.}^.link1)
FROM ZITGIST.MO.l_artist_artist as l_artist_artist where (^{artist.}^.id = ^{l_artist_artist.}^.link0) where (^{artist_artist.}^.id = ^{l_artist_artist.}^.link1)
FROM ZITGIST.MO.l_artist_track as l_artist_track where (^{artist.}^.id = ^{l_artist_track.}^.link0) where (^{artist_track.}^.id = ^{l_artist_track.}^.link1) FROM ZITGIST.MO.l_album_artist as l_album_artist where (^{artist.}^.id = ^{l_album_artist.}^.link1) where (^{artist_album.}^.id = ^{l_album_artist.}^.link0)
{ create virtrdf:MBZ as graph iri ("http://musicbrainz.org/") option (exclusive) {
# Track Composition Event
mbz:composition_iri (track.gid)
a mo:Composition as mbz:track_is_composition;
dc:title track.name as mbz:title_of_track;
mo:composer mbz:artist_iri (track_artist_creator.gid) as mbz:creator_composer_of_track;
mo:composer mbz:artist_iri (track_artist.gid) where (^{l_artist_track2.}^.link_type = 14) option (using l_artist_track2) as mbz:composer14_of_track;
mo:producesWork mbz:musicalwork_iri (track.gid) as mbz:track_producesWork.
# Track Musical Work
mbz:musicalwork_iri (track.gid)
a mo:MusicalWork as mbz:track_is_mw;
dc:title track.name as mbz:name_of_mw;
mo:productOfComposition mbz:composition_iri(track.gid) as mbz:mw_is_productOfComposition_of;
mo:usedInPerformance mbz:performance_iri(track.gid) as mbz:mw_usedInPerformance.
# Track Performance Event
mbz:performance_iri (track.gid)
a mo:Performance;
dc:title track.name;
mo:performer mbz:artist_iri (track_artist_creator.gid);
mo:performer mbz:artist_iri (track_artist.gid) where (^{l_artist_track2.}^.link_type = 2) option (using l_artist_track2);
mo:conductor mbz:artist_iri (track_artist.gid) where (^{l_artist_track2.}^.link_type = 9) option (using l_artist_track2);
mo:usesWork mbz:musicalwork_iri (track.gid);
mo:producesSound mbz:sound_iri (track.gid);
mo:recordedAs mbz:signal_iri(track.gid).
# Track Sound
mbz:sound_iri (track.gid)
a mo:Sound;
dc:title track.name;
mo:productOfPerformance mbz:performance_iri (track.gid);
mo:usedInRecording mbz:recording_iri (track.gid).
# Track Recording Event
mbz:recording_iri (track.gid)
a mo:Recording;
dc:title track.name;
mo:recordsSound mbz:sound_iri (track.gid);
mo:producesSignal mbz:signal_iri (track.gid).
# Track Signal (Musical Expression)
mbz:signal_iri (track.gid)
a mo:Signal;
dc:title track.name;
mo:remixer mbz:artist_iri (track_artist.gid) where (^{l_artist_track2.}^.link_type = 11) option (using l_artist_track2);
mo:sampler mbz:artist_iri (track_artist.gid) where (^{l_artist_track2.}^.link_type = 12) option (using l_artist_track2);
mo:djmixed mbz:artist_iri (track_artist.gid) where (^{l_artist_track2.}^.link_type = 40) option (using l_artist_track2);
mo:djmix_of mbz:track_iri (track_track.gid) where (^{l_track_track.}^.link_type = 13) option (using l_track_track);
mo:remix_of mbz:track_iri (track_track.gid) where (^{l_track_track.}^.link_type = 6) option (using l_track_track);
mo:remix_of mbz:track_iri (track_track.gid) where (^{l_track_track.}^.link_type = 11) option (using l_track_track);
mo:mashup_of mbz:track_iri (track_track.gid) where (^{l_track_track.}^.link_type = 8) option (using l_track_track);
mo:mashup_of mbz:track_iri (track_track.gid) where (^{l_track_track.}^.link_type = 4) option (using l_track_track);
mo:remaster_of mbz:track_iri (track_track.gid) where (^{l_track_track.}^.link_type = 3) option (using l_track_track);
mo:compilation_of mbz:track_iri (track_track.gid) where (^{l_track_track.}^.link_type = 10) option (using l_track_track);
mo:compilation_of mbz:track_iri (track_track.gid) where (^{l_track_track.}^.link_type = 12) option (using l_track_track);
mo:medley_of mbz:record_iri (track_track.gid) where (^{l_track_track.}^.link_type = 14) option (using l_track_track);
mo:published_as mbz:track_iri (track.gid);
mo:signalTime mbz:duration_iri(track.gid);
mo:puid track_puid.puid option (using puidjoin).
# Track duration
mbz:duration_iri(track.gid)
a timeline:Interval;
timeline:durationXSD mbz:duration(track.length).
mbz:track_iri(track.gid)
a mo:Track;
dc:title track.name;
mo:trackNum track_albumjoin.sequence;
dc:creator mbz:artist_iri (track_artist_creator.gid);
dc:creator mbz:artist_iri (track_artist.gid) where (^{l_artist_track2.}^.link_type = 14) option (using l_artist_track2);
mo:compiler mbz:artist_iri (track_artist.gid) where (^{l_artist_track2.}^.link_type = 39) option (using l_artist_track2);
mo:producer mbz:artist_iri (track_artist.gid) where (^{l_artist_track2.}^.link_type = 18) option (using l_artist_track2);
mo:publisher mbz:artist_iri (track_artist.gid) where (^{l_artist_track2.}^.link_type = 35) option (using l_artist_track2);
mo:engineer mbz:artist_iri (track_artist.gid) where (^{l_artist_track2.}^.link_type = 19) option (using l_artist_track2);
mo:licence mbz:url_iri(track_url.url) where (^{l_track_url.}^.link_type = 21) option (using l_track_url);
mo:paiddownload mbz:url_iri(track_url.url) where (^{l_track_url.}^.link_type = 16) option (using l_track_url);
mo:freedownload mbz:url_iri(track_url.url) where (^{l_track_url.}^.link_type = 17) option (using l_track_url);
mo:olga mbz:url_iri(track_url.url) where (^{l_track_url.}^.link_type = 19) option (using l_track_url);
mo:musicbrainz mbz:mbz_track_url_iri(track.gid);
mo:duration track.length.
# Record Composition Event
mbz:composition_iri (album.gid)
a mo:Composition;
dc:title album.name;
mo:composer mbz:artist_iri (album_artist_creator.gid);
mo:composer mbz:artist_iri (album_artist.gid) where (^{l_album_artist2.}^.link_type = 14) option (using l_album_artist2);
mo:producesWork mbz:musicalwork_iri (album.gid).
# Record Musical Work
mbz:musicalwork_iri (album.gid)
a mo:MusicalWork;
dc:title album.name;
mo:productOfComposition mbz:composition_iri(album.gid);
mo:usedInPerformance mbz:performance_iri(album.gid).
# Record Performance Event
mbz:performance_iri (album.gid)
a mo:Performance;
dc:title album.name;
mo:performer mbz:artist_iri (album_artist_creator.gid);
mo:performer mbz:artist_iri (album_artist.gid) where (^{l_album_artist2.}^.link_type = 2) option (using l_album_artist2);
mo:conductor mbz:artist_iri (album_artist.gid) where (^{l_album_artist2.}^.link_type = 9) option (using l_album_artist2);
mo:usesWork mbz:musicalwork_iri (album.gid);
mo:producesSound mbz:sound_iri (album.gid);
mo:recordedAs mbz:record_iri(album.gid).
# Record Sound
mbz:sound_iri (album.gid)
a mo:Sound;
dc:title album.name;
mo:productOfPerformance mbz:performance_iri (album.gid);
mo:usedInRecording mbz:recording_iri (album.gid).
# Record Recording Event
mbz:recording_iri (album.gid)
a mo:Recording;
dc:title album.name;
mo:recordsSound mbz:sound_iri (album.gid);
mo:producesSignal mbz:signal_iri (album.gid).
# Record Signal (Musical Expression)
mbz:signal_iri (album.gid)
a mo:Signal;
dc:title album.name;
mo:djmix_of mbz:record_iri (album_album.gid) where (^{l_album_album.}^.link_type = 9) option (using l_album_album);
mo:remix_of mbz:record_iri (album_album.gid) where (^{l_album_album.}^.link_type = 7) option (using l_album_album);
mo:remix_of mbz:record_iri (album_album.gid) where (^{l_album_album.}^.link_type = 4) option (using l_album_album);
mo:mashup_of mbz:record_iri (album_album.gid) where (^{l_album_album.}^.link_type = 5) option (using l_album_album);
mo:remaster_of mbz:record_iri (album_album.gid) where (^{l_album_album.}^.link_type = 3) option (using l_album_album);
mo:tribute_to mbz:artist_iri (album_artist.gid) where (^{l_album_artist2.}^.link_type = 44) option (using l_album_artist2);
mo:remixer mbz:artist_iri (album_artist.gid) where (^{l_album_artist2.}^.link_type = 11) option (using l_album_artist2);
mo:djmixed mbz:artist_iri (album_artist.gid) where (^{l_album_artist2.}^.link_type = 38) option (using l_album_artist2);
mo:sampler mbz:artist_iri (album_artist.gid) where (^{l_album_artist2.}^.link_type = 12) option (using l_album_artist2);
mo:published_as mbz:record_iri (album.gid).
# Record (Musical Manifestation)
mbz:record_iri (album.gid)
a mo:Record;
dc:title album.name;
dc:date mbz:created(album_release.releasedate);
mo:image mbz:image_iri(album_amazon_asin.asin);
#Empty for now.
mo:compilation_of mbz:record_iri (album_album.gid) where (^{l_album_album.}^.link_type = 8) option (using l_album_album);
mo:releaseStatus mbz:official_iri(album.attributes);
mo:releaseStatus mbz:promotion_iri(album.attributes);
mo:releaseStatus mbz:bootleg_iri(album.attributes);
mo:releaseType mbz:album_iri(album.attributes);
mo:releaseType mbz:single_iri(album.attributes);
mo:releaseType mbz:ep_iri(album.attributes);
mo:releaseType mbz:compilation_iri(album.attributes);
mo:releaseType mbz:soundtrack_iri(album.attributes);
mo:releaseType mbz:spokenword_iri(album.attributes);
mo:releaseType mbz:interview_iri(album.attributes);
mo:releaseType mbz:audiobook_iri(album.attributes);
mo:releaseType mbz:live_iri(album.attributes);
mo:releaseType mbz:remix_iri(album.attributes);
dc:creator mbz:artist_iri (album_artist_creator.gid);
dc:creator mbz:artist_iri (album_artist.gid) where (^{l_album_artist2.}^.link_type = 14) option (using l_album_artist2);
mo:compiler mbz:artist_iri (album_artist.gid) where (^{l_album_artist2.}^.link_type = 41) option (using l_album_artist2);
mo:producer mbz:artist_iri (album_artist.gid) where (^{l_album_artist2.}^.link_type = 18) option (using l_album_artist2);
mo:publisher mbz:artist_iri (album_artist.gid) where (^{l_album_artist2.}^.link_type = 35) option (using l_album_artist2);
mo:engineer mbz:artist_iri (album_artist.gid) where (^{l_album_artist2.}^.link_type = 19) option (using l_album_artist2);
mo:musicbrainz mbz:mbz_release_url_iri(album.gid);
mo:musicmoz mbz:url_iri(album_url.url) where (^{l_album_url.}^.link_type = 25) option (using l_album_url);
mo:discogs mbz:url_iri(album_url.url) where (^{l_album_url.}^.link_type = 24) option (using l_album_url);
mo:wikipedia mbz:url_iri(album_url.url) where (^{l_album_url.}^.link_type = 23) option (using l_album_url);
mo:discography mbz:url_iri(album_url.url) where (^{l_album_url.}^.link_type = 1) option (using l_album_url);
mo:freedownload mbz:url_iri(album_url.url) where (^{l_album_url.}^.link_type = 21) option (using l_album_url);
mo:discography mbz:url_iri(album_url.url) where (^{l_album_url.}^.link_type = 16) option (using l_album_url);
mo:mailorder mbz:url_iri(album_url.url) where (^{l_album_url.}^.link_type = 19) option (using l_album_url);
mo:imdb mbz:url_iri(album_url.url) where (^{l_album_url.}^.link_type = 27) option (using l_album_url);
mo:paiddownload mbz:url_iri(album_url.url) where (^{l_album_url.}^.link_type = 20) option (using l_album_url);
mo:licence mbz:url_iri(album_url.url) where (^{l_album_url.}^.link_type = 32) option (using l_album_url);
mo:review mbz:url_iri(album_url.url) where (^{l_album_url.}^.link_type = 17) option (using l_album_url);
mo:amazon_asin mbz:amazon_asin_iri(album_amazon_asin.asin);
mo:has_track mbz:track_iri (album_albumjoin_track.gid) option (using album_albumjoin).
# Music Group (Band)
mbz:artist_iri(band.gid)
a mo:MusicArtist;
a mo:MusicGroup;
a foaf:Group;
foaf:name band.name;
foaf:nick bandalias.name;
bio:event mbz:artist_birth_event_iri(band.gid);
bio:event mbz:artist_death_event_iri(band.gid);
mo:similar_to mbz:artist_iri(sim_band.gid) option (using band_relation);
mo:similar_to mbz:artist_iri(sim_artist.gid) option (using artist_relation);
foaf:member mbz:artist_iri(band_member.gid) option (using band_l_artist_artist);
# l_artist_url
mo:myspace mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 19) option (using l_artist_url3);
mo:musicmoz mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 12) option (using l_artist_url3);
mo:discogs mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 11) option (using l_artist_url3);
mo:wikipedia mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 10) option (using l_artist_url3);
mo:discography mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 1) option (using l_artist_url3);
mo:freedownload mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 8) option (using l_artist_url3);
mo:fanpage mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 3) option (using l_artist_url3);
mo:biography mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 4) option (using l_artist_url3);
mo:discography mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 5) option (using l_artist_url3);
mo:mailorder mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 15) option (using l_artist_url3);
mo:imdb mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 17) option (using l_artist_url3);
mo:paiddownload mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 7) option (using l_artist_url3);
foaf:depiction mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 14) option (using l_artist_url3);
foaf:homepage mbz:url_iri(band_url.url) where (^{l_artist_url3.}^.link_type = 2) option (using l_artist_url3);
mo:musicbrainz mbz:mbz_artist_url_iri(band.gid);
# l_album_artist
mo:composed mbz:composition_iri (band_album.gid) where (^{l_album_artist3.}^.link_type = 14) option (using l_album_artist3);
mo:performed mbz:performance_iri (band_album.gid) where (^{l_album_artist3.}^.link_type = 14) option (using l_album_artist3);
mo:performed mbz:performance_iri (band_album.gid) where (^{l_album_artist3.}^.link_type = 2) option (using l_album_artist3);
mo:conducted mbz:performance_iri (band_album.gid) where (^{l_album_artist3.}^.link_type = 9) option (using l_album_artist3);
mo:compiled mbz:record_iri (band_album.gid) where (^{l_album_artist3.}^.link_type = 41) option (using l_album_artist3);
mo:djmixed mbz:record_iri (band_album.gid) where (^{l_album_artist3.}^.link_type = 38) option (using l_album_artist3);
mo:remixed mbz:record_iri (band_album.gid) where (^{l_album_artist3.}^.link_type = 11) option (using l_album_artist3);
mo:sampled mbz:record_iri (band_album.gid) where (^{l_album_artist3.}^.link_type = 12) option (using l_album_artist3);
mo:produced mbz:record_iri (band_album.gid) where (^{l_album_artist3.}^.link_type = 18) option (using l_album_artist3);
mo:published mbz:record_iri (band_album.gid) where (^{l_album_artist3.}^.link_type = 35) option (using l_album_artist3);
mo:engineered mbz:record_iri (band_album.gid) where (^{l_album_artist3.}^.link_type = 19) option (using l_album_artist3);
foaf:made mbz:record_iri(band_album_creatorOf.gid);
# l_artist_track
mo:composed mbz:composition_iri (band_track.gid) where (^{l_artist_track3.}^.link_type = 14) option (using l_artist_track3);
mo:performed mbz:performance_iri (band_track.gid) where (^{l_artist_track3.}^.link_type = 14) option (using l_artist_track3);
mo:performed mbz:performance_iri (band_track.gid) where (^{l_artist_track3.}^.link_type = 2) option (using l_artist_track3);
mo:conducted mbz:performance_iri (band_track.gid) where (^{l_artist_track3.}^.link_type = 9) option (using l_artist_track3);
mo:compiled mbz:record_iri (band_track.gid) where (^{l_artist_track3.}^.link_type = 39) option (using l_artist_track3);
mo:djmixed mbz:track_iri (band_track.gid) where (^{l_artist_track3.}^.link_type = 40) option (using l_artist_track3);
mo:remixed mbz:track_iri (band_track.gid) where (^{l_artist_track3.}^.link_type = 11) option (using l_artist_track3);
mo:sampled mbz:track_iri (band_track.gid) where (^{l_artist_track3.}^.link_type = 12) option (using l_artist_track3);
mo:produced mbz:track_iri (band_track.gid) where (^{l_artist_track3.}^.link_type = 18) option (using l_artist_track3);
mo:published mbz:track_iri (band_track.gid) where (^{l_artist_track3.}^.link_type = 35) option (using l_artist_track3);
mo:engineered mbz:track_iri (band_track.gid) where (^{l_artist_track3.}^.link_type = 19) option (using l_artist_track3).
# Music Group (Band)'s Birth Event
mbz:artist_birth_event_iri(band.gid)
a bio:Birth;
bio:date band.begindate.
# Music Group (Band)'s Death Event
mbz:artist_death_event_iri(band.gid)
a bio:Death;
bio:date band.enddate.
# Similarity link
#mbz:sim_link_iri(sim_band.gid)
# sim:relation mo:similar_to;
# sim:level band_relation.weight;
# sim:to sim_band.gid.
# Music Artist
mbz:artist_iri (artist.gid)
# artist
a mo:MusicArtist;
a mo:SoloMusicArtist where (^{artist_untyped.}^.gid is not null) option (using artist_untyped);
a foaf:Person where (^{artist_untyped.}^.gid is not null) option (using artist_untyped);
foaf:name artist.name;
foaf:nick artistalias.name;
bio:event mbz:artist_birth_event_iri(artist.gid);
bio:event mbz:artist_death_event_iri(artist.gid);
mo:member_of mbz:artist_iri(artist_artist.gid) where (^{l_artist_artist.}^.link_type = 2) option (using l_artist_artist);
# l_artist_artist
rel:siblingOf mbz:artist_iri(artist_artist.gid) where (^{l_artist_artist.}^.link_type = 7) option (using l_artist_artist);
rel:friendOf mbz:artist_iri(artist_artist.gid) where (^{l_artist_artist.}^.link_type = 5) option (using l_artist_artist);
rel:parentOf mbz:artist_iri(artist_artist.gid) where (^{l_artist_artist.}^.link_type = 6) option (using l_artist_artist);
rel:collaborated_with mbz:artist_iri(artist_artist.gid) where (^{l_artist_artist.}^.link_type = 11) option (using l_artist_artist);
rel:engagedTo mbz:artist_iri(artist_artist.gid) where (^{l_artist_artist.}^.link_type = 9) option (using l_artist_artist);
rel:spouseOf mbz:artist_iri(artist_artist.gid) where (^{l_artist_artist.}^.link_type = 8) option (using l_artist_artist);
mo:supporting_musician mbz:artist_iri(artist_artist.gid) where (^{l_artist_artist.}^.link_type = 13) option (using l_artist_artist);
mo:supporting_musician mbz:artist_iri(artist_artist.gid) where (^{l_artist_artist.}^.link_type = 14) option (using l_artist_artist);
mo:supporting_musician mbz:artist_iri(artist_artist.gid) where (^{l_artist_artist.}^.link_type = 15) option (using l_artist_artist);
mo:similar_to mbz:artist_iri(sim_artist.gid) option (using artist_relation);
mo:similar_to mbz:artist_iri(sim_band.gid) option (using band_relation);
# l_artist_url
mo:myspace mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 19) option (using l_artist_url);
mo:musicmoz mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 12) option (using l_artist_url);
mo:discogs mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 11) option (using l_artist_url);
mo:wikipedia mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 10) option (using l_artist_url);
mo:discography mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 1) option (using l_artist_url);
mo:freedownload mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 8) option (using l_artist_url);
mo:fanpage mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 3) option (using l_artist_url);
mo:biography mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 4) option (using l_artist_url);
mo:discography mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 5) option (using l_artist_url);
mo:mailorder mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 15) option (using l_artist_url);
mo:imdb mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 17) option (using l_artist_url);
mo:paiddownload mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 7) option (using l_artist_url);
foaf:depiction mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 14) option (using l_artist_url);
foaf:homepage mbz:url_iri(artist_url.url) where (^{l_artist_url.}^.link_type = 2) option (using l_artist_url);
mo:musicbrainz mbz:mbz_artist_url_iri(artist.gid);
# l_album_artist
mo:composed mbz:composition_iri (artist_album.gid) where (^{l_album_artist.}^.link_type = 14) option (using l_album_artist);
mo:performed mbz:performance_iri (artist_album.gid) where (^{l_album_artist.}^.link_type = 14) option (using l_album_artist);
mo:performed mbz:performance_iri (artist_album.gid) where (^{l_album_artist.}^.link_type = 2) option (using l_album_artist);
mo:conducted mbz:performance_iri (artist_album.gid) where (^{l_album_artist.}^.link_type = 9) option (using l_album_artist);
mo:compiled mbz:record_iri (artist_album.gid) where (^{l_album_artist.}^.link_type = 41) option (using l_album_artist);
mo:djmixed mbz:record_iri (artist_album.gid) where (^{l_album_artist.}^.link_type = 38) option (using l_album_artist);
mo:remixed mbz:record_iri (artist_album.gid) where (^{l_album_artist.}^.link_type = 11) option (using l_album_artist);
mo:sampled mbz:record_iri (artist_album.gid) where (^{l_album_artist.}^.link_type = 12) option (using l_album_artist);
mo:produced mbz:record_iri (artist_album.gid) where (^{l_album_artist.}^.link_type = 18) option (using l_album_artist);
mo:published mbz:record_iri (artist_album.gid) where (^{l_album_artist.}^.link_type = 35) option (using l_album_artist);
mo:engineered mbz:record_iri (artist_album.gid) where (^{l_album_artist.}^.link_type = 19) option (using l_album_artist);
# mo:creatorOfRecord mbz:record_iri(artist_album_creatorOf.gid);
foaf:made mbz:record_iri(artist_album_creatorOf.gid);
# l_artist_track
mo:composed mbz:composition_iri (artist_track.gid) where (^{l_artist_track.}^.link_type = 14) option (using l_artist_track);
mo:performed mbz:performance_iri (artist_track.gid) where (^{l_artist_track.}^.link_type = 14) option (using l_artist_track);
mo:performed mbz:performance_iri (artist_track.gid) where (^{l_artist_track.}^.link_type = 2) option (using l_artist_track);
mo:conducted mbz:performance_iri (artist_track.gid) where (^{l_artist_track.}^.link_type = 9) option (using l_artist_track);
mo:compiled mbz:track_iri (artist_track.gid) where (^{l_artist_track.}^.link_type = 39) option (using l_artist_track);
mo:djmixed mbz:track_iri (artist_track.gid) where (^{l_artist_track.}^.link_type = 40) option (using l_artist_track);
mo:remixed mbz:track_iri (artist_track.gid) where (^{l_artist_track.}^.link_type = 11) option (using l_artist_track);
mo:sampled mbz:track_iri (artist_track.gid) where (^{l_artist_track.}^.link_type = 12) option (using l_artist_track);
mo:produced mbz:track_iri (artist_track.gid) where (^{l_artist_track.}^.link_type = 18) option (using l_artist_track);
mo:published mbz:track_iri (artist_track.gid) where (^{l_artist_track.}^.link_type = 35) option (using l_artist_track);
mo:engineered mbz:track_iri (artist_track.gid) where (^{l_artist_track.}^.link_type = 19) option (using l_artist_track).
# mo:creatorOfTrack mbz:track_iri(artist_track_creatorOf.gid).
# Music Artist''s Birth Event
mbz:artist_birth_event_iri(artist.gid)
a bio:Birth;
bio:date artist.begindate.
# Music Artist''s Death Event
mbz:artist_death_event_iri(artist.gid)
a bio:Death;
bio:date artist.enddate.
# Similarity link
#mbz:sim_link_iri(sim_artist.gid)
# sim:relation mo:similar_to;
# sim:level artist_relation.weight;
# sim:to sim_artist.gid.
}
} ; ```
The new lines you mention really are present in the text content of the element. HTML tags are not being replaced by new lines, they just get omitted entirely. If you look at the textContent property of the <p> element you selected in the browser console, and you'll see the same new lines. Also if you select the text and run window.getSelection().getRangeAt(0).toString() in the browser console you'll see the same new lines. In summary, this is working as it is currently expected to. What I think may have been surprising here is that the captured text is not the same as what would be copied to the clipboard. When copying to the clipboard, new lines in the source get replaced with spaces, and <br> tags get converted to new lines. Browser specifications distinguish the original text content of HTML "in the source" as returned by element.textContent from the text content "as rendered" returned by element.innerText. Hypothesis has always captured quotes from and searched for quotes in the "source" text content rather than the "rendered" text. This behavior causes issues with line breaks as well. It might make sense for us to look at capturing the rendered text (as copied to the clipboard) rather than the source text in future. We'd need to be careful to handle all the places where this distinction comes up, and also make sure that all existing annotations anchor properly. Also we should talk to other parties interested in the Web Annotations specifications to discuss how this impacts interoperability.
What I think may have been surprising here is that the captured text is not the same as what would be copied to the clipboard. When <mark>copying to the clipboard, <mark style="background-color: #8000314f">new lines in the source</mark> get <mark style="background-color:#00800030">replaced with spaces</mark>, and <br> tags get converted to new lines</mark>. </br> <mark>Browser specifications distinguish <mark style="background-color: #00800036">the original text content of HTML "in the source"</mark> as returned by <mark style="background-color: #00800036"/>element.textContent</mark> from <mark style="background-color: #ffa500a1">the text content "as rendered" returned by element.innerText.</mark></mark> Hypothesis has always captured quotes from and searched for quotes in the "source" text content rather than the "rendered" text.
Differences from innerHTML Element.innerHTML returns HTML, as its name indicates. Sometimes people use innerHTML to retrieve or write text inside an element, but textContent has better performance because its value is not parsed as HTML. Moreover, using textContent can prevent XSS attacks.
Differences from innerText Don't get confused by the differences between Node.textContent and HTMLElement.innerText. Although the names seem similar, there are important differences: textContent gets the content of all elements, including <script> and <style> elements. In contrast, innerText only shows "human-readable" elements. textContent returns every element in the node. In contrast, innerText is aware of styling and won't return the text of "hidden" elements. Moreover, since innerText takes CSS styles into account, reading the value of innerText triggers a reflow to ensure up-to-date computed styles. (Reflows can be computationally expensive, and thus should be avoided when possible.) Both textContent and innerText remove child nodes when altered, but altering innerText in Internet Explorer (version 11 and below) also permanently destroys all descendant text nodes. It is impossible to insert the nodes again into any other element or into the same element after doing so.
html
<md>
# Markdown Support
Awesomeness
</md>
html
<github-md># Example </github-md>
class: Person class: Project property: worksOn worksOn domain Person worksOn range Project
xml
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:doap="http://usefulinc.com/ns/doap#">
<doap:Project>
<doap:name>Example project</doap:name>
<doap:homepage rdf:resource="http://example.com" />
<doap:programming-language>javascript</doap:programming-language>
<doap:license rdf:resource="http://example.com/doap/licenses/gpl"/>
</doap:Project>
</rdf:RDF>
```xml
<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns='http://usefulinc.com/ns/doap#' xmlns:xmpp='https://linkmauve.fr/ns/xmpp-doap#' xmlns:schema='https://schema.org'> <Project> <name>poezio</name>
<created>2010-01-10</created>
<shortdesc xml:lang='en'>Free console XMPP client</shortdesc>
<shortdesc xml:lang='fr'>Client XMPP libre en console</shortdesc>
<description xml:lang='en'>Free and modern console XMPP client written in Python with the ncurses library</description>
<description xml:lang='fr'>Client console XMPP libre et moderne, écrit en Python avec la bibliothèque ncurses</description>
<homepage rdf:resource='https://poez.io/'/>
<schema:documentation rdf:resource='https://doc.poez.io/'/>
<download-page rdf:resource='https://poez.io/#download'/>
<bug-database rdf:resource='https://lab.louiz.org/poezio/poezio/-/issues'/>
<developer-forum rdf:resource='xmpp:poezio@muc.poez.io?join'/>
<support-forum rdf:resource='xmpp:poezio@muc.poez.io?join'/>
<license rdf:resource='https://git.poez.io/poezio/plain/COPYING'/>
<language>en</language>
<schema:logo rdf:resource='https://poez.io/img/logo.svg'/>
<schema:screenshot rdf:resource='https://poez.io/img/screenshot.png'/>
<programming-language>Python</programming-language>
<os>Linux</os>
<category rdf:resource='https://linkmauve.fr/ns/xmpp-doap#category-client'/>
<repository>
<GitRepository>
<browse rdf:resource='https://lab.louiz.org/poezio/poezio'/>
<location rdf:resource='https://lab.louiz.org/poezio/poezio.git'/>
</GitRepository>
</repository>
<implements rdf:resource='https://xmpp.org/rfcs/rfc6120.html'/>
<implements rdf:resource='https://xmpp.org/rfcs/rfc6121.html'/>
<implements rdf:resource='https://xmpp.org/rfcs/rfc6122.html'/>
<implements rdf:resource='https://xmpp.org/rfcs/rfc7590.html'/>
<implements>
<xmpp:SupportedXep>
<xmpp:xep rdf:resource='https://xmpp.org/extensions/xep-0030.html'/>
<xmpp:status>complete</xmpp:status>
<xmpp:version>2.5rc3</xmpp:version>
<xmpp:since>0.5</xmpp:since>
<xmpp:note xml:lang='en'>The 'disco' plugin can be loaded to make manual queries.</xmpp:note>
<xmpp:note xml:lang='fr'>Le plugin 'disco' peut être chargé pour faire des requêtes manuellement.</xmpp:note>
</xmpp:SupportedXep>
</implements>
<!-- And a lot more! -->
<release>
<Version>
<revision>0.13.1</revision>
<created>2020-05-31</created>
<file-release rdf:resource='https://lab.louiz.org/poezio/poezio/-/archive/v0.13.1/poezio-v0.13.1.tar.gz'/>
</Version>
</release>
</Project> </rdf:RDF> ```
<channel> Elements: <sy:updatePeriod> ( 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' ) <sy:updateFrequency> ( a positive integer ) <sy:updateBase> ( #PCDATA ) [W3CDTF]
'art19': 'https://art19.com/xmlns/rss-extensions/1.0', 'atom': 'http://www.w3.org/2005/Atom', 'atom10': 'http://www.w3.org/2005/Atom"', 'cc': 'http://web.resource.org/cc/', 'content': 'http://purl.org/rss/1.0/modules/content/', 'creativeCommons': 'http://backend.userland.com/creativeCommonsRssModule', 'dc': 'http://purl.org/dc/elements/1.1/', 'ddn': 'http://discoverydn.com/about', 'feedburner': 'http://rssnamespace.org/feedburner/ext/1.0', 'feedpress': 'https://feed.press/xmlns', 'geo': 'http://www.w3.org/2003/01/geo/wgs84_pos#', 'georss': 'http://www.georss.org/georss', 'googleplay': 'http://www.google.com/schemas/play-podcasts/1.0', 'itunes': 'http://www.itunes.com/dtds/podcast-1.0.dtd', 'media': 'http://search.yahoo.com/mrss/', 'npr': 'https://www.npr.org/rss/', 'nprml': 'https://api.npr.org/nprml', 'rawvoice': 'http://www.rawvoice.com/rawvoiceRssModule/', 'rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#', 'slash': 'http://purl.org/rss/1.0/modules/slash/', 'sr': 'http://www.sverigesradio.se/podrss', 'sy': 'http://purl.org/rss/1.0/modules/syndication/', 'wfw': 'http://wellformedweb.org/CommentAPI/',
```turtle
@prefix rdfs: http://www.w3.org/2000/01/rdf-schema# . @prefix rdf: http://www.w3.org/1999/02/22-rdf-syntax-ns# . @prefix vcard: http://www.w3.org/2006/vcard/ns# . @prefix emp: http://www.snee.com/schema/employees/ .
emp:Person rdf:type rdfs:Class ; rdfs:label "person" .
emp:Employee a rdfs:Class ; rdfs:label "employee" ; rdfs:comment "A full-time, non-contractor employee." .
vcard:given-name rdf:type rdf:Property ; rdfs:label "given name".
vcard:family-name rdf:type rdf:Property ; rdfs:label "family name" ; rdfs:label "apellido"@es .
emp:hireDate a rdf:Property ; rdfs:label "hire date" ; rdfs:comment "The first day an employee was on the payroll." .
emp:reportsTo a rdf:Property ; rdfs:label "reports to" . ```
```sparql PREFIX rdfs: http://www.w3.org/2000/01/rdf-schema# PREFIX i: http://learningsparql.com/ns/instrument/ PREFIX s: http://learningsparql.com/ns/schema/ PREFIX b: http://www.bobdc.com/ns/beatles/
SELECT ?britishGroup WHERE { ?bassist b:favoriteBritishGroup ?britishGroup . SERVICE https://dydra.com/bobdc/beatles-musicians/sparql { SELECT ?bassist WHERE { ?song a s:Song ; rdfs:label "The Long And Winding Road" ; i:bass ?bassist . } } } ```
sparql
PREFIX osmt: <https://wiki.openstreetmap.org/wiki/Key:>
SELECT * WHERE {
?museum osmt:addr:city "New York";
osmt:tourism "museum";
osmt:wikidata ?wikidataID .
}
```sparql PREFIX rdf: http://www.w3.org/1999/02/22-rdf-syntax-ns# PREFIX skos: http://www.w3.org/2004/02/skos/core# PREFIX schema: http://schema.org/ prefix owl: http://www.w3.org/2002/07/owl# prefix rdfs: http://www.w3.org/2000/01/rdf-schema#
CONSTRUCT { http://schema.org/ a skos:ConceptScheme ; skos:hasTopConcept schema:Thing . ?child a skos:Concept ; skos:broaderTransitive ?parent ; skos:broader ?ancestors ; skos:prefLabel ?label ; skos:definition ?desc ; skos:inScheme ?ext . ?parent skos:narrowerTransitive ?child . ?ancestors skos:narrower ?child .<br /> } WHERE { ?child rdfs:subClassOf ?parent . ?child rdfs:subClassOf+ ?ancestors . OPTIONAL { ?child rdfs:label ?label } OPTIONAL { ?child rdfs:comment ?desc } OPTIONAL { ?child schema:isPartOf ?ext } } ```
json
{
"@context": "http://schema.org",
"@type": "ArchiveOrganization",
"name": "Example Archives",
"@id": "http://examplearchive.org",
"archiveHeld": {
"@type": ["ArchiveComponent","Collection"],
"@id": "http://examplearchive.org/coll1",
"name": "Example Archive Collection",
"collectionSize": 1,
"holdingArchive": "http://examplearchive.org",
"hasPart": {
"@type": ["ArchiveComponent","Manuscript"],
"@id": "http://examplearchive.org/item1",
"name": "Interesting Manuscript",
"description": "Interesting manuscript - on loan to the British Library",
"itemLocation": "http://bl.uk",
"isPartOf": "http://examplearchive.org/coll1"
}
}
}`
json
{
"@context": "http://schema.org",
"@graph": [
{
"@type": "DefinedTerm",
"@id": "http://hotexample.com/terms/sf1",
"name": "Coal",
"inDefinedTermSet": "http://hotexample.com/terms"
},
{
"@type": "DefinedTerm",
"@id": "http://hotexample.com/terms/sf2",
"name": "Coke",
"inDefinedTermSet": "http://hotexample.com/terms"
},
{
"@type": "DefinedTerm",
"@id": "http://hotexample.com/terms/sf3",
"name": "Biomass",
"inDefinedTermSet": "http://hotexample.com/terms"
},
{
"@type": "DefinedTerm",
"@id": "http://hotexample.com/terms/sf4",
"name": "Peat",
"inDefinedTermSet": "http://hotexample.com/terms"
},
{
"@type": "DefinedTermSet",
"@id": "http://hotexample.com/terms",
"name": "Solid Fuel Terms"
}
]
}
json
{
"@context": "http://schema.org",
"@graph": [
{
"@type": "DefinedTerm",
"@id": "http://hotexample.com/terms/sf1",
"name": "Coal",
"inDefinedTermSet": "http://hotexample.com/terms"
},
{
"@type": "DefinedTerm",
"@id": "http://hotexample.com/terms/sf2",
"name": "Coke",
"inDefinedTermSet": "http://hotexample.com/terms"
},
{
"@type": "DefinedTerm",
"@id": "http://hotexample.com/terms/sf3",
"name": "Biomass",
"inDefinedTermSet": "http://hotexample.com/terms"
},
{
"@type": "DefinedTerm",
"@id": "http://hotexample.com/terms/sf4",
"name": "Peat",
"inDefinedTermSet": "http://hotexample.com/terms"
},
{
"@type": "DefinedTermSet",
"@id": "http://hotexample.com/terms",
"name": "Solid Fuel Terms"
}
]
}
`rel=”alternate”’ - used to refer to the HTML version of an entry or feed `rel=”related”’ - used to refer to related feeds `rel=”self”’ - used to refer to the canonical URL for this feed or entry `rel=”enclosure”’ - used to refer to podcasts, or other related rich media content `rel=”replies”’ - used to refer to a feed containing the comments related to this entry `rel=”via”’
```js import { useState } from "react"; import "./styles.css";
const VIDEO_LINKS = [ "https://www.sample-videos.com/video123/mp4/240/big_buck_bunny_240p_2mb.mp4", "https://www.sample-videos.com/video123/mp4/480/big_buck_bunny_480p_2mb.mp4", "https://www.sample-videos.com/video123/mp4/720/big_buck_bunny_720p_20mb.mp4" ];
export default function App() { const [switchVideo, setSwitchVideo] = useState(0); const [videoWidth, setVideoWidth] = useState(null); const [videoHeight, setVideoHeight] = useState(null);
return ( <div className="App"> <video src={VIDEO_LINKS[switchVideo]} controls style= onResize={(e) => { setVideoWidth(e.target.videoWidth); setVideoHeight(e.target.videoHeight); }} /> <div className="resButton"> <button onClick={() => setSwitchVideo(0)}>240p</button> <button onClick={() => setSwitchVideo(1)}>480p</button> <button onClick={() => setSwitchVideo(2)}>720p</button> </div> </div> ); } ```
json
{
"success": true,
"message": "User logged in successfully",
"data": {
"user": {
"id": 2,
"name": "Client",
"client_id": 1,
"email": "client@clickapps.co",
"gender_label": null,
"gender": null,
"mobile": "123654789",
"code_country": "00967",
"birth_date": null,
"avatar": "http://localhost:3000/default_image.png",
"sms_notification": true,
"is_mobile_verified": false,
"otp": {
"otp": "8704"
},
"client_city": {
"id": 3,
"name_ar": "الرياض",
"name_en": "Riadh",
"name": "Riadh",
"status": 1,
"status_label": "Active",
"country": {
"id": 2,
"name": "Kingdub saudi Arab",
"code_country": "ksa",
"avatar": "http://localhost:3000/default_image.png",
"status": 1,
"status_label": "Active"
}
},
"client_locations": [
{
"id": 1,
"client_id": 1,
"latitude": "0.0",
"longitude": "0.0",
"address": "169 Rath Rapids",
"address_ar": "964 Michale Parkway",
"address_en": "169 Rath Rapids",
"building_name": "building_name",
"location_type": 1,
"location_type_label": "Home",
"apartment_name": null,
"require_permission": false,
"city": null,
"zip_code": null
}
]
},
"role": "client",
"token": "eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MiwibmFtZSI6IkNsaWVudCIsImVtYWlsIjoiY2xpZW50QGNsaWNrYXBwcy5jbyIsIm1vYmlsZSI6IjEyMzY1NDc4OSIsImltYWdlIjoiL2RlZmF1bHRfaW1hZ2UucG5nIiwiYWRtaW4iOmZhbHNlLCJpYXQiOjE1NDc5MjU0MzIsImV4cCI6MTU1MDUxNzQzMn0.4Vyjd7BG7v8AFSmGKmIs4VM2FBw3gOLn97Qdf6U4jxU"
}
}
If you want to fetch comics and metadata automatically, you can use the JSON interface. The URLs look like this: https://xkcd.com/info.0.json (current comic) or: https://xkcd.com/614/info.0.json (comic #614) Those files contain, in a plaintext and easily-parsed format: comic titles, URLs, post dates, transcripts (when available), and other metadata.
```css .long-text { margin-bottom: 10px; }
.clamp { -webkit-line-clamp: 5; -webkit-box-orient: vertical; display: -webkit-box; overflow: hidden; text-overflow: ellipsis; overflow-wrap: break-word; } ```
```js import { LoremIpsum } from "https://cdn.skypack.dev/lorem-ipsum@2.0.3"; import classnames from "https://cdn.skypack.dev/classnames@2.3.1"; import * as lodash from "https://cdn.skypack.dev/lodash@4.17.21";
const getText = (paragraphs) => { const lorem = new LoremIpsum(); return lorem.generateParagraphs(paragraphs); };
const ReadMoreText = ({ text }) => { const [clamped, setClamped] = React.useState(true); const [showButton, setShowButton] = React.useState(true); const containerRef = React.useRef(null); const handleClick = () => setClamped(!clamped);
React.useEffect(() => { const hasClamping = (el) => { const { clientHeight, scrollHeight } = el; return clientHeight !== scrollHeight; };
const checkButtonAvailability = () => {
if (containerRef.current) {
// Save current state to reapply later if necessary.
const hadClampClass = containerRef.current.classList.contains("clamp");
// Make sure that CSS clamping is applied if aplicable.
if (!hadClampClass) containerRef.current.classList.add("clamp");
// Check for clamping and show or hide button accordingly.
setShowButton(hasClamping(containerRef.current));
// Sync clamping with local state.
if (!hadClampClass) containerRef.current.classList.remove("clamp");
}
};
const debouncedCheck = lodash.debounce(checkButtonAvailability, 50);
checkButtonAvailability();
window.addEventListener("resize", debouncedCheck);
return () => {
window.removeEventListener("resize", debouncedCheck);
};
}, [containerRef]);
return ( <> <div ref={containerRef} className={classnames("long-text", clamped && "clamp")} > {text} </div> {showButton && ( <button onClick={handleClick}>Read {clamped ? "more" : "less"}</button> )} <br /> ); };
const App = () => { const text = getText(2); return <ReadMoreText text={text} />; };
ReactDOM.render(<App />, document.getElementById("App")); ```
about: Specifies the subject of a relationship. If not given, then the subject is the current document.
rel : Defines a relation between the subject and a URL given by either href or resource. The subject is either specified by the closest about or src attribute, @@
rev : The same as the the rel attribute, except that subject and object are reversed.
property : Defines a relationship between the subject and either a string (if the content attribute is present) or a piece of markup otherwise (the content of the element that the property attribute is on).
content : Specifies a string to use as an object for the property attribute
href : Specifies an object URI for the rev and rel attributes. <mark>Takes precedence over the resource attribute</mark>.
resource : Specifies an object URI for the rev and rel attributes if href is not present.
src : Specifies the subject of a relationship.
datatype : Specifies a datatype of the object of the property attribute (either in the content attribute, or the content of the element that the datattype attribute is on.) By default, data in the content attribute is of type string, and data in the content of an element has type xml:Literal. If datatype="" is used, then for the RDF the element content is stripped of markup, and is of type string.
typeof : Creates a blank node, which becomes the subject, and asserts that the current element contains relationships that match the given RDF type.
js
var camelCased = myString.replace(/-([a-z])/g, function (g) { return g[1].toUpperCase(); });
**The Cauchy-Schwarz Inequality**
$$\left( \sum_{k=1}^n a_k b_k \right)^2 \leq \left( \sum_{k=1}^n a_k^2 \right) \left( \sum_{k=1}^n b_k^2 \right)$$
This sentence uses $ delimiters to show math inline: $\sqrt{3x-1}+(1+x)^2$
bash
$ curl https://api.specref.org/search-refs?q=json-ld | jq '.'
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 38628 100 38628 0 0 44605 0 --:--:-- --:--:-- --:--:-- 44553
{
"JSON-LD-TESTS": {
"authors": [
"RDF Working Group"
],
"href": "https://www.w3.org/2013/json-ld-tests/",
"title": "JSON-LD 1.0 Test Suite",
"date": "11 April 2013",
"status": "ED",
"publisher": "W3C",
"id": "JSON-LD-TESTS"
},
"json-ld": {
"authors": [
"Manu Sporny",
"Gregg Kellogg",
"Markus Lanthaler"
],
"href": "https://www.w3.org/TR/json-ld/",
"title": "JSON-LD 1.0",
"status": "REC",
"publisher": "W3C",
"deliveredBy": [
{
"url": "https://www.w3.org/2011/rdf-wg/",
"shortname": "rdf"
}
],
"versions": [
"json-ld-20201103",
"json-ld-20140116",
"json-ld-20131105",
"json-ld-20130910",
"json-ld-20130411",
"json-ld-20120712"
],
"id": "json-ld",
"date": "3 November 2020"
},
...
http://youtube.com/watch_videos?video_ids=AAAAAAAAAAA,BBBBBBBBBBB,CCCCCCCCCCC,DDDDDDDDDDD
http://youtube.com/watch?v=AAAAAAAAAAA&list=EEEEEEEEEEEEEEEEEEEEEEEE
http://youtube.com/playlist?list=EEEEEEEEEEEEEEEEEEEEEEEE
To select an element tag or attribute defined in a specific namespace, you declare a namespace prefix with an @namespace rule, then use it in your selector. The namespace is separated from the tag name with a | (vertical bar or pipe) character; if there is no tag name in the selector, use a universal * selector:
```css @namespace svg "http://www.w3.org/2000/svg";
a { / These rules would apply to any a elements. /
text-decoration: underline;
color: purple;
}
svg|a { / These rules would apply to SVG a elements,
but not HTML links. /
stroke: purple;
}
svg| { / These rules apply to all SVG-namespaced elements,
but not HTML elements. */
mix-blend-mode: multiply;
}
```
``` HTTP/1.1 200 OK Content-Type: application/ld+json Link: http://api.example.com/doc/; rel="http://www.w3.org/ns/hydra/core#apiDocumentation"
{ "@context": "http://www.w3.org/ns/hydra/context.jsonld", "@graph": [{ "@id": "http://api.example.com/people", "@type": "hydra:Collection", "api:personByName": "api:PersonByNameTemplate" }, { "@id": "http://api.example.com/events", "@type": "hydra:Collection", "api:eventByName": "api:EventByNameTemplate" } } ```
```css .dont-break-out {
/ These are technically the same, but use both / overflow-wrap: break-word; word-wrap: break-word;
-ms-word-break: break-all; / This is the dangerous one in WebKit, as it breaks things wherever / word-break: break-all; / Instead use this non-standard one: / word-break: break-word;
/ Adds a hyphen where the word breaks, if supported (No Blink) / -ms-hyphens: auto; -moz-hyphens: auto; -webkit-hyphens: auto; hyphens: auto;
} ```
The GS1 Web Vocabulary collects terms defined in various GS1 standards and data systems and made available for general use following Linked Data principles. It is designed as an extension to schema.org and, where relevant, mappings and relationships arising from that vocabulary are made explicit. The initial focus of the GS1 Web Vocabulary is consumer-facing properties for clothing, shoes, food beverage/tobacco and properties common to all products.
ORCID est structuré conformément à la norme ISNI et les deux organisations ont signé un accord pour asseoir et améliorer leur interopérabilité. Ainsi, ORCID utilise l’ISNI pour l’identification des institutions auxquelles les chercheurs sont affiliés.